refactor(onboarding): drop old page

.github/workflows/jsci.yaml

@@ -56,17 +56,6 @@ jobs:
       PRIMUS_REF: main
       JS_SRC: frontend
       JS_PKG_MANAGER: pnpm
-  languages:
-    if: |
-      github.event_name == 'merge_group' ||
-      (github.event_name == 'pull_request' && ! github.event.pull_request.head.repo.fork && github.event.pull_request.user.login != 'dependabot[bot]' && ! contains(github.event.pull_request.labels.*.name, 'safe-to-test')) ||
-      (github.event_name == 'pull_request_target' && contains(github.event.pull_request.labels.*.name, 'safe-to-test'))
-    runs-on: ubuntu-latest
-    steps:
-      - name: self-checkout
-        uses: actions/checkout@v4
-      - name: run
-        run: bash frontend/scripts/validate-md-languages.sh
   openapi:
     if: |
       github.event_name == 'merge_group' ||

frontend/scripts/extract-md-languages.sh

@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-# Extracts unique fenced code block language identifiers from all .md files under frontend/src/
-# Usage: bash frontend/scripts/extract-md-languages.sh
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-SRC_DIR="$SCRIPT_DIR/../src"
-
-grep -roh '```[a-zA-Z0-9_+-]*' "$SRC_DIR" --include='*.md' \
-  | sed 's/^```//' \
-  | grep -v '^$' \
-  | sort -u

frontend/scripts/validate-md-languages.sh

@@ -1,41 +0,0 @@
-#!/usr/bin/env bash
-# Validates that all fenced code block languages used in .md files are registered
-# in the syntax highlighter.
-# Usage: bash frontend/scripts/validate-md-languages.sh
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-SYNTAX_HIGHLIGHTER="$SCRIPT_DIR/../src/components/MarkdownRenderer/syntaxHighlighter.ts"
-
-# Get all languages used in .md files
-md_languages=$("$SCRIPT_DIR/extract-md-languages.sh")
-
-# Get all registered languages from syntaxHighlighter.ts
-registered_languages=$(grep -oP "registerLanguage\('\K[^']+" "$SYNTAX_HIGHLIGHTER" | sort -u)
-
-missing_languages=()
-
-for lang in $md_languages; do
-  # Skip ai-* block markers — these are custom AI block types rendered by
-  # RichCodeBlock as React components (e.g. ActionBlock, LineChartBlock),
-  # not real syntax languages, so they don't need highlighter registration.
-  if [[ "$lang" == ai-* ]]; then
-    continue
-  fi
-  if ! echo "$registered_languages" | grep -qx "$lang"; then
-    missing_languages+=("$lang")
-  fi
-done
-
-if [ ${#missing_languages[@]} -gt 0 ]; then
-  echo "Error: The following languages are used in .md files but not registered in syntaxHighlighter.ts:"
-  for lang in "${missing_languages[@]}"; do
-    echo "  - $lang"
-  done
-  echo ""
-  echo "Please add them to: frontend/src/components/MarkdownRenderer/syntaxHighlighter.ts"
-  exit 1
-fi
-
-echo "All markdown code block languages are registered in syntaxHighlighter.ts"

frontend/src/AppRoutes/Private.tsx

@@ -3,7 +3,6 @@ import { matchPath, Redirect, useLocation } from 'react-router-dom';
 import getLocalStorageApi from 'api/browser/localstorage/get';
 import setLocalStorageApi from 'api/browser/localstorage/set';
 import { useListUsers } from 'api/generated/services/users';
-import { FeatureKeys } from 'constants/features';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import { ORG_PREFERENCES } from 'constants/orgPreferences';
 import ROUTES from 'constants/routes';
@@ -37,7 +36,6 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 		activeLicense,
 		isFetchingActiveLicense,
 		trialInfo,
-		featureFlags,
 	} = useAppContext();
 
 	const isAdmin = user.role === USER_ROLES.ADMIN;
@@ -212,14 +210,6 @@ function PrivateRoute({ children }: PrivateRouteProps): JSX.Element {
 		}
 	}
 
-	// Check for GET_STARTED → GET_STARTED_WITH_CLOUD redirect (feature flag)
-	if (
-		currentRoute?.path === ROUTES.GET_STARTED &&
-		featureFlags?.find((e) => e.name === FeatureKeys.ONBOARDING_V3)?.active
-	) {
-		return <Redirect to={ROUTES.GET_STARTED_WITH_CLOUD} />;
-	}
-
 	// Main routing logic
 	if (currentRoute) {
 		const { isPrivate, key } = currentRoute;

frontend/src/AppRoutes/__tests__/Private.test.tsx

@@ -2,7 +2,6 @@ import { ReactElement } from 'react';
 import { QueryClient, QueryClientProvider } from 'react-query';
 import { MemoryRouter, Route, Switch, useLocation } from 'react-router-dom';
 import { act, render, screen, waitFor } from '@testing-library/react';
-import { FeatureKeys } from 'constants/features';
 import { LOCALSTORAGE } from 'constants/localStorage';
 import { ORG_PREFERENCES } from 'constants/orgPreferences';
 import ROUTES from 'constants/routes';
@@ -1263,80 +1262,6 @@ describe('PrivateRoute', () => {
 		});
 	});
 
-	describe('Get Started Route Redirect', () => {
-		it('should redirect to GET_STARTED_WITH_CLOUD when on GET_STARTED and ONBOARDING_V3 feature flag is active', async () => {
-			renderPrivateRoute({
-				initialRoute: ROUTES.GET_STARTED,
-				appContext: {
-					isLoggedIn: true,
-					featureFlags: [
-						{
-							name: FeatureKeys.ONBOARDING_V3,
-							active: true,
-							usage: 0,
-							usage_limit: -1,
-							route: '',
-						},
-					],
-				},
-			});
-
-			await assertRedirectsTo(ROUTES.GET_STARTED_WITH_CLOUD);
-		});
-
-		it('should not redirect when on GET_STARTED and ONBOARDING_V3 feature flag is inactive', () => {
-			renderPrivateRoute({
-				initialRoute: ROUTES.GET_STARTED,
-				appContext: {
-					isLoggedIn: true,
-					featureFlags: [
-						{
-							name: FeatureKeys.ONBOARDING_V3,
-							active: false,
-							usage: 0,
-							usage_limit: -1,
-							route: '',
-						},
-					],
-				},
-			});
-
-			assertStaysOnRoute(ROUTES.GET_STARTED);
-		});
-
-		it('should not redirect when on GET_STARTED and ONBOARDING_V3 feature flag is not present', () => {
-			renderPrivateRoute({
-				initialRoute: ROUTES.GET_STARTED,
-				appContext: {
-					isLoggedIn: true,
-					featureFlags: [],
-				},
-			});
-
-			assertStaysOnRoute(ROUTES.GET_STARTED);
-		});
-
-		it('should not redirect when on different route even if ONBOARDING_V3 is active', () => {
-			renderPrivateRoute({
-				initialRoute: ROUTES.HOME,
-				appContext: {
-					isLoggedIn: true,
-					featureFlags: [
-						{
-							name: FeatureKeys.ONBOARDING_V3,
-							active: true,
-							usage: 0,
-							usage_limit: -1,
-							route: '',
-						},
-					],
-				},
-			});
-
-			assertStaysOnRoute(ROUTES.HOME);
-		});
-	});
-
 	describe('Loading States', () => {
 		it('should not redirect while license is still being fetched', () => {
 			renderPrivateRoute({
@@ -1496,16 +1421,16 @@ describe('PrivateRoute', () => {
 			await assertRedirectsTo(ROUTES.UN_AUTHORIZED);
 		});
 
-		it('should allow EDITOR to access /get-started route', () => {
+		it('should allow EDITOR to access /get-started-with-signoz-cloud route', () => {
 			renderPrivateRoute({
-				initialRoute: ROUTES.GET_STARTED,
+				initialRoute: ROUTES.GET_STARTED_WITH_CLOUD,
 				appContext: {
 					isLoggedIn: true,
 					user: createMockUser({ role: USER_ROLES.EDITOR as ROLES }),
 				},
 			});
 
-			assertStaysOnRoute(ROUTES.GET_STARTED);
+			assertStaysOnRoute(ROUTES.GET_STARTED_WITH_CLOUD);
 		});
 	});
 

frontend/src/AppRoutes/pageComponents.ts

@@ -90,14 +90,6 @@ export const SettingsPage = Loadable(
 	() => import(/* webpackChunkName: "SettingsPage" */ 'pages/Settings'),
 );
 
-export const GettingStarted = Loadable(
-	() => import(/* webpackChunkName: "GettingStarted" */ 'pages/GettingStarted'),
-);
-
-export const Onboarding = Loadable(
-	() => import(/* webpackChunkName: "Onboarding" */ 'pages/OnboardingPage'),
-);
-
 export const OrgOnboarding = Loadable(
 	() => import(/* webpackChunkName: "OrgOnboarding" */ 'pages/OrgOnboarding'),
 );

frontend/src/AppRoutes/routes.ts

@@ -33,7 +33,6 @@ import {
 	MeterExplorerPage,
 	MetricsExplorer,
 	OldLogsExplorer,
-	Onboarding,
 	OnboardingV2,
 	OrgOnboarding,
 	PasswordReset,
@@ -70,13 +69,6 @@ const routes: AppRoutes[] = [
 		isPrivate: false,
 		key: 'SIGN_UP',
 	},
-	{
-		path: ROUTES.GET_STARTED,
-		exact: false,
-		component: Onboarding,
-		isPrivate: true,
-		key: 'GET_STARTED',
-	},
 	{
 		path: ROUTES.GET_STARTED_WITH_CLOUD,
 		exact: false,

frontend/src/components/MessagingQueueHealthCheck/AttributeCheckList.tsx

@@ -62,13 +62,13 @@ function ErrorTitleAndKey({
 
 		switch (parentTitle) {
 			case 'Consumers':
-				link = `${ROUTES.GET_STARTED_APPLICATION_MONITORING}?${QueryParams.getStartedSource}=kafka&${QueryParams.getStartedSourceService}=${MessagingQueueHealthCheckService.Consumers}`;
+				link = `${ROUTES.GET_STARTED_WITH_CLOUD}?${QueryParams.getStartedSource}=self-hosted-kafka&${QueryParams.getStartedSourceService}=${MessagingQueueHealthCheckService.Consumers}`;
 				break;
 			case 'Producers':
-				link = `${ROUTES.GET_STARTED_APPLICATION_MONITORING}?${QueryParams.getStartedSource}=kafka&${QueryParams.getStartedSourceService}=${MessagingQueueHealthCheckService.Producers}`;
+				link = `${ROUTES.GET_STARTED_WITH_CLOUD}?${QueryParams.getStartedSource}=self-hosted-kafka&${QueryParams.getStartedSourceService}=${MessagingQueueHealthCheckService.Producers}`;
 				break;
 			case 'Kafka':
-				link = `${ROUTES.GET_STARTED_INFRASTRUCTURE_MONITORING}?${QueryParams.getStartedSource}=kafka&${QueryParams.getStartedSourceService}=${MessagingQueueHealthCheckService.Kafka}`;
+				link = `${ROUTES.GET_STARTED_WITH_CLOUD}?${QueryParams.getStartedSource}=self-hosted-kafka&${QueryParams.getStartedSourceService}=${MessagingQueueHealthCheckService.Kafka}`;
 				break;
 			default:
 				link = '';

frontend/src/constants/features.ts

@@ -7,7 +7,6 @@ export enum FeatureKeys {
 	GATEWAY = 'gateway',
 	PREMIUM_SUPPORT = 'premium_support',
 	ANOMALY_DETECTION = 'anomaly_detection',
-	ONBOARDING_V3 = 'onboarding_v3',
 	DOT_METRICS_ENABLED = 'dot_metrics_enabled',
 	USE_JSON_BODY = 'use_json_body',
 	USE_FINE_GRAINED_AUTHZ = 'use_fine_grained_authz',

frontend/src/constants/routes.ts

@@ -11,14 +11,7 @@ const ROUTES = {
 	TRACE_DETAIL_OLD: '/trace-old/:id',
 	TRACES_EXPLORER: '/traces-explorer',
 	ONBOARDING: '/onboarding',
-	GET_STARTED: '/get-started',
 	GET_STARTED_WITH_CLOUD: '/get-started-with-signoz-cloud',
-	GET_STARTED_APPLICATION_MONITORING: '/get-started/application-monitoring',
-	GET_STARTED_LOGS_MANAGEMENT: '/get-started/logs-management',
-	GET_STARTED_INFRASTRUCTURE_MONITORING:
-		'/get-started/infrastructure-monitoring',
-	GET_STARTED_AWS_MONITORING: '/get-started/aws-monitoring',
-	GET_STARTED_AZURE_MONITORING: '/get-started/azure-monitoring',
 	USAGE_EXPLORER: '/usage-explorer',
 	APPLICATION: '/services',
 	ALL_DASHBOARD: '/dashboard',

frontend/src/container/AppLayout/index.tsx

@@ -413,14 +413,8 @@ function AppLayout(props: AppLayoutProps): JSX.Element {
 	const isPanelEditorV2 = routeKey === 'DASHBOARD_PANEL_EDITOR';
 
 	const renderFullScreen =
-		pathname === ROUTES.GET_STARTED ||
 		pathname === ROUTES.ONBOARDING ||
 		pathname === ROUTES.GET_STARTED_WITH_CLOUD ||
-		pathname === ROUTES.GET_STARTED_APPLICATION_MONITORING ||
-		pathname === ROUTES.GET_STARTED_INFRASTRUCTURE_MONITORING ||
-		pathname === ROUTES.GET_STARTED_LOGS_MANAGEMENT ||
-		pathname === ROUTES.GET_STARTED_AWS_MONITORING ||
-		pathname === ROUTES.GET_STARTED_AZURE_MONITORING ||
 		isPublicDashboard ||
 		isPanelEditorV2;
 

frontend/src/container/FullScreenHeader/FullScreenHeader.styles.scss

@@ -1,29 +0,0 @@
-.full-screen-header-container {
-	display: flex;
-	justify-content: center;
-	align-items: center;
-	padding: 24px 0;
-
-	.brand-logo {
-		display: flex;
-		justify-content: center;
-		align-items: center;
-		gap: 16px;
-		cursor: pointer;
-
-		img {
-			height: 32px;
-			width: 32px;
-		}
-
-		.brand-logo-name {
-			font-family: 'Work Sans', sans-serif;
-			font-size: 24px;
-			font-style: normal;
-			font-weight: 500;
-			line-height: 18px;
-
-			color: var(--l1-foreground);
-		}
-	}
-}

frontend/src/container/FullScreenHeader/FullScreenHeader.tsx

@@ -1,28 +0,0 @@
-import history from 'lib/history';
-
-import signozBrandLogoUrl from '@/assets/Logos/signoz-brand-logo.svg';
-
-import './FullScreenHeader.styles.scss';
-
-export default function FullScreenHeader({
-	overrideRoute,
-}: {
-	overrideRoute?: string;
-}): React.ReactElement {
-	const handleLogoClick = (): void => {
-		history.push(overrideRoute || '/');
-	};
-	return (
-		<div className="full-screen-header-container">
-			<div className="brand-logo" onClick={handleLogoClick}>
-				<img src={signozBrandLogoUrl} alt="SigNoz" />
-
-				<div className="brand-logo-name">SigNoz</div>
-			</div>
-		</div>
-	);
-}
-
-FullScreenHeader.defaultProps = {
-	overrideRoute: '/',
-};

frontend/src/container/NoLogs/NoLogs.tsx

@@ -33,15 +33,7 @@ export default function NoLogs({
 			} else if (dataSource === DataSource.METRICS) {
 				logEvent('Metrics Explorer: Navigate to onboarding', {});
 			}
-			let link;
-			if (dataSource === DataSource.TRACES) {
-				link = ROUTES.GET_STARTED_APPLICATION_MONITORING;
-			} else if (dataSource === DataSource.METRICS) {
-				link = ROUTES.GET_STARTED_WITH_CLOUD;
-			} else {
-				link = ROUTES.GET_STARTED_LOGS_MANAGEMENT;
-			}
-			history.push(link);
+			history.push(ROUTES.GET_STARTED_WITH_CLOUD);
 		} else if (dataSource === 'traces') {
 			openInNewTab(DOCLINKS.TRACES_EXPLORER_EMPTY_STATE);
 		} else if (dataSource === DataSource.METRICS) {

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Docker/QuickStart/dotnet-docker-quickStart-instrumentApplication.md

@@ -1,106 +0,0 @@
-
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
- 
-
-### Step 2:  Adding OpenTelemetry as a service and configuring exporter options
-
-In your `Program.cs` file, add OpenTelemetry as a service. Here, we are configuring these variables:
-
-`serviceName` - It is the name of your service.
-
-`otlpOptions.Endpoint` - It is the endpoint for your OTel Collector agent.
-
- 
-
-Here’s a sample `Program.cs` file with the configured variables:
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-        resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-                        //sigNoz Cloud Endpoint 
-            otlpOptions.Endpoint = new Uri("https://ingest.{{REGION}}.signoz.cloud:443");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-                        
-                        //SigNoz Cloud account Ingestion key
-            string headerKey = "signoz-ingestion-key";
-            string headerValue = "{{SIGNOZ_INGESTION_KEY}}";
-
-            string formattedHeader = $"{headerKey}={headerValue}";
-            otlpOptions.Headers = formattedHeader;
-        }));
-
-var app = builder.Build();
-
-//The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
-
- 
-
-
-The OpenTelemetry.Exporter.Options get or set the target to which the exporter is going to send traces. Here, we’re configuring it to send traces to the OTel Collector agent. The target must be a valid Uri with the scheme (http or https) and host and may contain a port and a path.
-
-This is done by configuring an OpenTelemetry [TracerProvider](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/customizing-the-sdk#readme) using extension methods and setting it to auto-start when the host is started.
-
-
-### Step 3: Dockerize your application
-
-Since the environment variables like SIGNOZ_INGESTION_KEY, Ingestion Endpoint and Service name are set in the `program.cs` file, you don't need to add any additional steps in your Dockerfile.
-
-An **example** of a Dockerfile could look like this:
-
-```bash
-
-# Use the Microsoft official .NET SDK image to build the application
-FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build-env
-WORKDIR /app
-
-# Copy the CSPROJ file and restore any dependencies (via NUGET)
-COPY *.csproj ./
-RUN dotnet restore
-
-# Copy the rest of the project files and build the application
-COPY . ./
-RUN dotnet publish -c Release -o out
-
-# Generate the runtime image
-FROM mcr.microsoft.com/dotnet/aspnet:8.0
-WORKDIR /app
-COPY --from=build-env /app/out .
-
-# Expose port 5145 for the application
-EXPOSE 5145
-
-# Set the ASPNETCORE_URLS environment variable to listen on port 5145
-ENV ASPNETCORE_URLS=http://+:5145
-
-ENTRYPOINT ["dotnet", "YOUR-APPLICATION.dll"]
-```

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Docker/QuickStart/dotnet-docker-quickStart-runApplication.md

@@ -1,21 +0,0 @@
-Once you update your Dockerfile, you can build and run it using the commands below.
-
- 
-
-### Step 1: Build your dockerfile
-
-Build your docker image
-
-```bash
-docker build -t <your-image-name> .
-```
-
-- `<your-image-name>` is the name of your Docker Image
-
-&nbsp;
-
-### Step 2: Run your docker image
-
-```bash
-docker run <your-image-name>
-```

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Docker/Recommended/dotnet-docker-recommended-installOtelCollector.md

@@ -1,12 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
-
- 
-
-As a first step, you should install the OTel collector Binary according to the instructions provided on [this link](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/).
-
- 
-
-Once you are done setting up the OTel collector binary, you can follow the next steps.
-
- 
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Docker/Recommended/dotnet-docker-recommended-instrumentApplication.md

@@ -1,101 +0,0 @@
-After setting up the Otel collector agent, follow the steps below to instrument your .NET Application
-
- 
- 
-
-### Step 1: Install OpenTelemetry Dependencies
-Install the following dependencies in your application.
-
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
- 
-
-### Step 2:  Adding OpenTelemetry as a service and configuring exporter options
-
-In your `Program.cs` file, add OpenTelemetry as a service. Here, we are configuring these variables:
-
-`serviceName` - It is the name of your service.
-
-`otlpOptions.Endpoint` - It is the endpoint for your OTel Collector agent.
-
- 
-
-Here’s a sample `Program.cs` file with the configured variables:
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-        resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-            otlpOptions.Endpoint = new Uri("http://localhost:4317");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-        }));
-
-var app = builder.Build();
-
-//The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
- 
-
-The OpenTelemetry.Exporter.Options get or set the target to which the exporter is going to send traces. Here, we’re configuring it to send traces to the OTel Collector agent. The target must be a valid Uri with the scheme (http or https) and host and may contain a port and a path.
-
-This is done by configuring an OpenTelemetry [TracerProvider](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/customizing-the-sdk#readme) using extension methods and setting it to auto-start when the host is started.
-
-
- 
-
-### Step 3: Dockerize your application
-
-Since the crucial environment variables like SIGNOZ_INGESTION_KEY, Ingestion Endpoint and Service name are set in the `program.cs` file, you don't need to add any additional steps in your Dockerfile.
-
-An **example** of a Dockerfile could look like this:
-
-```bash
-
-# Use the Microsoft official .NET SDK image to build the application
-FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build-env
-WORKDIR /app
-
-# Copy the CSPROJ file and restore any dependencies (via NUGET)
-COPY *.csproj ./
-RUN dotnet restore
-
-# Copy the rest of the project files and build the application
-COPY . ./
-RUN dotnet publish -c Release -o out
-
-# Generate the runtime image
-FROM mcr.microsoft.com/dotnet/aspnet:8.0
-WORKDIR /app
-COPY --from=build-env /app/out .
-
-# Expose port 5145 for the application
-EXPOSE 5145
-
-# Set the ASPNETCORE_URLS environment variable to listen on port 5145
-ENV ASPNETCORE_URLS=http://+:5145
-
-ENTRYPOINT ["dotnet", "YOUR-APPLICATION.dll"]
-```

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Docker/Recommended/dotnet-docker-recommended-runApplication.md

@@ -1,21 +0,0 @@
-Once you update your Dockerfile, you can build and run it using the commands below.
-
- 
-
-### Step 1: Build your dockerfile
-
-Build your docker image
-
-```bash
-docker build -t <your-image-name> .
-```
-
-- `<your-image-name>` is the name of your Docker Image
-
-&nbsp;
-
-### Step 2: Run your docker image
-
-```bash
-docker run <your-image-name>
-```

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Kubernetes/dotnet-kubernetes-installOtelCollector.md

@@ -1,43 +0,0 @@
-### Install otel-collector in your Kubernetes infra
-
-Add the SigNoz Helm Chart repository
-```bash
-helm repo add signoz https://charts.signoz.io
-```
-
- 
-
-If the chart is already present, update the chart to the latest using:
-```bash
-helm repo update
-```
-
- 
-
-For generic Kubernetes clusters, you can create *override-values.yaml* with the following configuration:
-
-```yaml
-global:
-  cloud: others
-  clusterName: <CLUSTER_NAME>
-  deploymentEnvironment: <DEPLOYMENT_ENVIRONMENT>
-otelCollectorEndpoint: ingest.{{REGION}}.signoz.cloud:443
-otelInsecure: false
-signozApiKey: {{SIGNOZ_INGESTION_KEY}}
-presets:
-  otlpExporter:
-    enabled: true
-  loggingExporter:
-    enabled: false
-```
-
-- Replace `<CLUSTER_NAME>` with the name of the Kubernetes cluster or a unique identifier of the cluster.
-- Replace `<DEPLOYMENT_ENVIRONMENT>` with the deployment environment of your application. Example: **"staging"**, **"production"**, etc.
-
-&nbsp;
-
-To install the k8s-infra chart with the above configuration, run the following command:
-
-```bash
-helm install my-release signoz/k8s-infra -f override-values.yaml
-```

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Kubernetes/dotnet-kubernetes-instrumentApplication.md

@@ -1,65 +0,0 @@
-After setting up the Otel collector agent, follow the steps below to instrument your .NET Application
- 
- 
-
-### Step 1: Install OpenTelemetry Dependencies
-Install the following dependencies in your application.
-
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
- 
-
-### Step 2:  Adding OpenTelemetry as a service and configuring exporter options
-
-In your `Program.cs` file, add OpenTelemetry as a service. Here, we are configuring these variables:
-
-`serviceName` - It is the name of your service.
-
-`otlpOptions.Endpoint` - It is the endpoint for your OTel Collector agent.
-
- 
-
-Here’s a sample `Program.cs` file with the configured variables:
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-        resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-            otlpOptions.Endpoint = new Uri("http://localhost:4317");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-        }));
-
-var app = builder.Build();
-
-//The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
-
-The OpenTelemetry.Exporter.Options get or set the target to which the exporter is going to send traces. Here, we’re configuring it to send traces to the OTel Collector agent. The target must be a valid Uri with the scheme (http or https) and host and may contain a port and a path.
-
-This is done by configuring an OpenTelemetry [TracerProvider](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/customizing-the-sdk#readme) using extension methods and setting it to auto-start when the host is started.
-
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Kubernetes/dotnet-kubernetes-runApplication.md

@@ -1,10 +0,0 @@
- 
-
-To run your .NET application, use the below command :
-
-```bash
-dotnet build
-dotnet run
-```
-
-Once you run your .NET application, interact with your application to generate some load and see your application in the SigNoz UI.

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/LinuxAMD64/QuickStart/dotnet-linuxamd64-quickStart-instrumentApplication.md

@@ -1,71 +0,0 @@
-
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
- 
-
-### Step 2:  Adding OpenTelemetry as a service and configuring exporter options
-
-In your `Program.cs` file, add OpenTelemetry as a service. Here, we are configuring these variables:
-
-`serviceName` - It is the name of your service.
-
-`otlpOptions.Endpoint` - It is the endpoint for your OTel Collector agent.
-
- 
-
-Here’s a sample `Program.cs` file with the configured variables:
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-        resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-                        //sigNoz Cloud Endpoint 
-            otlpOptions.Endpoint = new Uri("https://ingest.{{REGION}}.signoz.cloud:443");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-                        
-                        //SigNoz Cloud account Ingestion key
-            string headerKey = "signoz-ingestion-key";
-            string headerValue = "{{SIGNOZ_INGESTION_KEY}}";
-
-            string formattedHeader = $"{headerKey}={headerValue}";
-            otlpOptions.Headers = formattedHeader;
-        }));
-
-var app = builder.Build();
-
-//The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
-
- 
-
-
-The OpenTelemetry.Exporter.Options get or set the target to which the exporter is going to send traces. Here, we’re configuring it to send traces to the OTel Collector agent. The target must be a valid Uri with the scheme (http or https) and host and may contain a port and a path.
-
-This is done by configuring an OpenTelemetry [TracerProvider](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/customizing-the-sdk#readme) using extension methods and setting it to auto-start when the host is started.

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/LinuxAMD64/QuickStart/dotnet-linuxamd64-quickStart-runApplication.md

@@ -1,10 +0,0 @@
- 
-To run your .NET application, use the below command :
-
-```bash
-dotnet build
-dotnet run
-```
-
-Once you run your .NET application, interact with your application to generate some load and see your application in the SigNoz UI.
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/LinuxAMD64/Recommended/dotnet-linuxamd64-recommended-installOtelCollector.md

@@ -1,98 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
- 
-
-### Step 1: Download otel-collector tar.gz
-```bash
-wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v{{OTEL_VERSION}}/otelcol-contrib_{{OTEL_VERSION}}_linux_amd64.tar.gz
-```
-
- 
-
-### Step 2: Extract otel-collector tar.gz to the `otelcol-contrib` folder
-```bash
-mkdir otelcol-contrib && tar xvzf otelcol-contrib_{{OTEL_VERSION}}_linux_amd64.tar.gz -C otelcol-contrib
-```
-
- 
-
-### Step 3: Create `config.yaml` in `otelcol-contrib` folder with the below content in it
-```bash
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: 0.0.0.0:4317
-      http:
-        endpoint: 0.0.0.0:4318
-  hostmetrics:
-    collection_interval: 60s
-    scrapers:
-      cpu: {}
-      disk: {}
-      load: {}
-      filesystem: {}
-      memory: {}
-      network: {}
-      paging: {}
-      process:
-        mute_process_name_error: true
-        mute_process_exe_error: true
-        mute_process_io_error: true
-      processes: {}
-  prometheus:
-    config:
-      global:
-        scrape_interval: 60s
-      scrape_configs:
-        - job_name: otel-collector-binary
-          static_configs:
-            - targets:
-              # - localhost:8888
-processors:
-  batch:
-    send_batch_size: 1000
-    timeout: 10s
-  # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
-  resourcedetection:
-    detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
-    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
-    timeout: 2s
-    system:
-      hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
-extensions:
-  health_check: {}
-  zpages: {}
-exporters:
-  otlp:
-    endpoint: "ingest.{{REGION}}.signoz.cloud:443"
-    tls:
-      insecure: false
-    headers:
-      "signoz-ingestion-key": "{{SIGNOZ_INGESTION_KEY}}"
-  logging:
-    verbosity: normal
-service:
-  telemetry:
-    metrics:
-      address: 0.0.0.0:8888
-  extensions: [health_check, zpages]
-  pipelines:
-    metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    metrics/internal:
-      receivers: [prometheus, hostmetrics]
-      processors: [resourcedetection, batch]
-      exporters: [otlp]
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    logs:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/LinuxAMD64/Recommended/dotnet-linuxamd64-recommended-instrumentApplication.md

@@ -1,67 +0,0 @@
-After setting up the Otel collector agent, follow the steps below to instrument your .NET Application
-
- 
- 
-
-### Step 1: Install OpenTelemetry Dependencies
-Install the following dependencies in your application.
-
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
- 
-
-### Step 2:  Adding OpenTelemetry as a service and configuring exporter options
-
-In your `Program.cs` file, add OpenTelemetry as a service. Here, we are configuring these variables:
-
-`serviceName` - It is the name of your service.
-
-`otlpOptions.Endpoint` - It is the endpoint for your OTel Collector agent.
-
- 
-
-Here’s a sample `Program.cs` file with the configured variables:
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-        resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-            otlpOptions.Endpoint = new Uri("http://localhost:4317");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-        }));
-
-var app = builder.Build();
-
-//The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
- 
-
-The OpenTelemetry.Exporter.Options get or set the target to which the exporter is going to send traces. Here, we’re configuring it to send traces to the OTel Collector agent. The target must be a valid Uri with the scheme (http or https) and host and may contain a port and a path.
-
-This is done by configuring an OpenTelemetry [TracerProvider](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/customizing-the-sdk#readme) using extension methods and setting it to auto-start when the host is started.
-
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/LinuxAMD64/Recommended/dotnet-linuxamd64-recommended-runApplication.md

@@ -1,18 +0,0 @@
- 
-Once you are done intrumenting your .NET application, you can run it using the below commands
- 
-
-### Step 1: Run OTel Collector
- Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step
-
-```bash
-./otelcol-contrib --config ./config.yaml
-```
-
- 
-
-### Step 2: Run your .NET application
-```bash
-dotnet build
-dotnet run
-```

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/LinuxARM64/QuickStart/dotnet-linuxarm64-quickStart-instrumentApplication.md

@@ -1,70 +0,0 @@
-
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
- 
-
-### Step 2:  Adding OpenTelemetry as a service and configuring exporter options
-
-In your `Program.cs` file, add OpenTelemetry as a service. Here, we are configuring these variables:
-
-`serviceName` - It is the name of your service.
-
-`otlpOptions.Endpoint` - It is the endpoint for your OTel Collector agent.
-
- 
-
-Here’s a sample `Program.cs` file with the configured variables:
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-        resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-                        //sigNoz Cloud Endpoint 
-            otlpOptions.Endpoint = new Uri("https://ingest.{{REGION}}.signoz.cloud:443");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-                        
-                        //SigNoz Cloud account Ingestion key
-            string headerKey = "signoz-ingestion-key";
-            string headerValue = "{{SIGNOZ_INGESTION_KEY}}";
-
-            string formattedHeader = $"{headerKey}={headerValue}";
-            otlpOptions.Headers = formattedHeader;
-        }));
-
-var app = builder.Build();
-
-//The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
-
- 
-
-The OpenTelemetry.Exporter.Options get or set the target to which the exporter is going to send traces. Here, we’re configuring it to send traces to the OTel Collector agent. The target must be a valid Uri with the scheme (http or https) and host and may contain a port and a path.
-
-This is done by configuring an OpenTelemetry [TracerProvider](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/customizing-the-sdk#readme) using extension methods and setting it to auto-start when the host is started.

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/LinuxARM64/QuickStart/dotnet-linuxarm64-quickStart-runApplication.md

@@ -1,10 +0,0 @@
- 
-To run your .NET application, use the below command :
-
-```bash
-dotnet build
-dotnet run
-```
-
-Once you run your .NET application, interact with your application to generate some load and see your application in the SigNoz UI.
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/LinuxARM64/Recommended/dotnet-linuxarm64-recommended-installOtelCollector.md

@@ -1,99 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
-
- 
-
-### Step 1: Download otel-collector tar.gz
-```bash
-wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v{{OTEL_VERSION}}/otelcol-contrib_{{OTEL_VERSION}}_linux_arm64.tar.gz
-```
-
- 
-
-### Step 2: Extract otel-collector tar.gz to the `otelcol-contrib` folder
-```bash
-mkdir otelcol-contrib && tar xvzf otelcol-contrib_{{OTEL_VERSION}}_linux_arm64.tar.gz -C otelcol-contrib
-```
-
- 
-
-### Step 3: Create `config.yaml` in `otelcol-contrib` folder with the below content in it
-```bash
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: 0.0.0.0:4317
-      http:
-        endpoint: 0.0.0.0:4318
-  hostmetrics:
-    collection_interval: 60s
-    scrapers:
-      cpu: {}
-      disk: {}
-      load: {}
-      filesystem: {}
-      memory: {}
-      network: {}
-      paging: {}
-      process:
-        mute_process_name_error: true
-        mute_process_exe_error: true
-        mute_process_io_error: true
-      processes: {}
-  prometheus:
-    config:
-      global:
-        scrape_interval: 60s
-      scrape_configs:
-        - job_name: otel-collector-binary
-          static_configs:
-            - targets:
-              # - localhost:8888
-processors:
-  batch:
-    send_batch_size: 1000
-    timeout: 10s
-  # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
-  resourcedetection:
-    detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
-    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
-    timeout: 2s
-    system:
-      hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
-extensions:
-  health_check: {}
-  zpages: {}
-exporters:
-  otlp:
-    endpoint: "ingest.{{REGION}}.signoz.cloud:443"
-    tls:
-      insecure: false
-    headers:
-      "signoz-ingestion-key": "{{SIGNOZ_INGESTION_KEY}}"
-  logging:
-    verbosity: normal
-service:
-  telemetry:
-    metrics:
-      address: 0.0.0.0:8888
-  extensions: [health_check, zpages]
-  pipelines:
-    metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    metrics/internal:
-      receivers: [prometheus, hostmetrics]
-      processors: [resourcedetection, batch]
-      exporters: [otlp]
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    logs:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/LinuxARM64/Recommended/dotnet-linuxarm64-recommended-instrumentApplication.md

@@ -1,68 +0,0 @@
-After setting up the Otel collector agent, follow the steps below to instrument your .NET Application
-
- 
- 
-
-### Step 1: Install OpenTelemetry Dependencies
-Install the following dependencies in your application.
-
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
- 
-
-### Step 2:  Adding OpenTelemetry as a service and configuring exporter options
-
-In your `Program.cs` file, add OpenTelemetry as a service. Here, we are configuring these variables:
-
-`serviceName` - It is the name of your service.
-
-`otlpOptions.Endpoint` - It is the endpoint for your OTel Collector agent.
-
- 
-
-Here’s a sample `Program.cs` file with the configured variables:
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-        resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-            otlpOptions.Endpoint = new Uri("http://localhost:4317");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-        }));
-
-var app = builder.Build();
-
-//The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
-
- 
-
-The OpenTelemetry.Exporter.Options get or set the target to which the exporter is going to send traces. Here, we’re configuring it to send traces to the OTel Collector agent. The target must be a valid Uri with the scheme (http or https) and host and may contain a port and a path.
-
-This is done by configuring an OpenTelemetry [TracerProvider](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/customizing-the-sdk#readme) using extension methods and setting it to auto-start when the host is started.
-
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/LinuxARM64/Recommended/dotnet-linuxarm64-recommended-runApplication.md

@@ -1,18 +0,0 @@
- 
-Once you are done intrumenting your .NET application, you can run it using the below commands
- 
-
-### Step 1: Run OTel Collector
- Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step
-
-```bash
-./otelcol-contrib --config ./config.yaml
-```
-
- 
-
-### Step 2: Run your .NET application
-```bash
-dotnet build
-dotnet run
-```

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/MacOsAMD64/QuickStart/dotnet-macosamd64-quickStart-instrumentApplication.md

@@ -1,70 +0,0 @@
-
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
- 
-
-### Step 2:  Adding OpenTelemetry as a service and configuring exporter options
-
-In your `Program.cs` file, add OpenTelemetry as a service. Here, we are configuring these variables:
-
-`serviceName` - It is the name of your service.
-
-`otlpOptions.Endpoint` - It is the endpoint for your OTel Collector agent.
-
- 
-
-Here’s a sample `Program.cs` file with the configured variables:
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-        resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-                        //sigNoz Cloud Endpoint 
-            otlpOptions.Endpoint = new Uri("https://ingest.{{REGION}}.signoz.cloud:443");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-                        
-                        //SigNoz Cloud account Ingestion key
-            string headerKey = "signoz-ingestion-key";
-            string headerValue = "{{SIGNOZ_INGESTION_KEY}}";
-
-            string formattedHeader = $"{headerKey}={headerValue}";
-            otlpOptions.Headers = formattedHeader;
-        }));
-
-var app = builder.Build();
-
-//The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
-
- 
-
-The OpenTelemetry.Exporter.Options get or set the target to which the exporter is going to send traces. Here, we’re configuring it to send traces to the OTel Collector agent. The target must be a valid Uri with the scheme (http or https) and host and may contain a port and a path.
-
-This is done by configuring an OpenTelemetry [TracerProvider](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/customizing-the-sdk#readme) using extension methods and setting it to auto-start when the host is started.

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/MacOsAMD64/QuickStart/dotnet-macosamd64-quickStart-runApplication.md

@@ -1,10 +0,0 @@
- 
-To run your .NET application, use the below command :
-
-```bash
-dotnet build
-dotnet run
-```
-
-Once you run your .NET application, interact with your application to generate some load and see your application in the SigNoz UI.
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/MacOsAMD64/Recommended/dotnet-macosamd64-recommended-installOtelCollector.md

@@ -1,97 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
- 
-
-### Step 1: Download otel-collector tar.gz
-```bash
-wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v{{OTEL_VERSION}}/otelcol-contrib_{{OTEL_VERSION}}_darwin_amd64.tar.gz
-```
- 
-
-### Step 2: Extract otel-collector tar.gz to the `otelcol-contrib` folder
-```bash
-mkdir otelcol-contrib && tar xvzf otelcol-contrib_{{OTEL_VERSION}}_darwin_amd64.tar.gz -C otelcol-contrib
-```
-
- 
-
-### Step 3: Create `config.yaml` in folder `otelcol-contrib` with the below content in it
-```bash
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: 0.0.0.0:4317
-      http:
-        endpoint: 0.0.0.0:4318
-  hostmetrics:
-    collection_interval: 60s
-    scrapers:
-      cpu: {}
-      disk: {}
-      load: {}
-      filesystem: {}
-      memory: {}
-      network: {}
-      paging: {}
-      process:
-        mute_process_name_error: true
-        mute_process_exe_error: true
-        mute_process_io_error: true
-      processes: {}
-  prometheus:
-    config:
-      global:
-        scrape_interval: 60s
-      scrape_configs:
-        - job_name: otel-collector-binary
-          static_configs:
-            - targets:
-              # - localhost:8888
-processors:
-  batch:
-    send_batch_size: 1000
-    timeout: 10s
-  # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
-  resourcedetection:
-    detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
-    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
-    timeout: 2s
-    system:
-      hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
-extensions:
-  health_check: {}
-  zpages: {}
-exporters:
-  otlp:
-    endpoint: "ingest.{{REGION}}.signoz.cloud:443"
-    tls:
-      insecure: false
-    headers:
-      "signoz-ingestion-key": "{{SIGNOZ_INGESTION_KEY}}"
-  logging:
-    verbosity: normal
-service:
-  telemetry:
-    metrics:
-      address: 0.0.0.0:8888
-  extensions: [health_check, zpages]
-  pipelines:
-    metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    metrics/internal:
-      receivers: [prometheus, hostmetrics]
-      processors: [resourcedetection, batch]
-      exporters: [otlp]
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    logs:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/MacOsAMD64/Recommended/dotnet-macosamd64-recommended-instrumentApplication.md

@@ -1,67 +0,0 @@
-After setting up the Otel collector agent, follow the steps below to instrument your .NET Application
-
- 
- 
-
-### Step 1: Install OpenTelemetry Dependencies
-Install the following dependencies in your application.
-
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
- 
-
-### Step 2:  Adding OpenTelemetry as a service and configuring exporter options
-
-In your `Program.cs` file, add OpenTelemetry as a service. Here, we are configuring these variables:
-
-`serviceName` - It is the name of your service.
-
-`otlpOptions.Endpoint` - It is the endpoint for your OTel Collector agent.
-
- 
-
-Here’s a sample `Program.cs` file with the configured variables:
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-        resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-            otlpOptions.Endpoint = new Uri("http://localhost:4317");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-        }));
-
-var app = builder.Build();
-
-//The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
- 
-
-The OpenTelemetry.Exporter.Options get or set the target to which the exporter is going to send traces. Here, we’re configuring it to send traces to the OTel Collector agent. The target must be a valid Uri with the scheme (http or https) and host and may contain a port and a path.
-
-This is done by configuring an OpenTelemetry [TracerProvider](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/customizing-the-sdk#readme) using extension methods and setting it to auto-start when the host is started.
-
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/MacOsAMD64/Recommended/dotnet-macosamd64-recommended-runApplication.md

@@ -1,18 +0,0 @@
- 
-Once you are done intrumenting your .NET application, you can run it using the below commands
- 
-
-### Step 1: Run OTel Collector
- Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step
-
-```bash
-./otelcol-contrib --config ./config.yaml
-```
-
- 
-
-### Step 2: Run your .NET application
-```bash
-dotnet build
-dotnet run
-```

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/MacOsARM64/QuickStart/dotnet-macosarm64-quickStart-instrumentApplication.md

@@ -1,70 +0,0 @@
-
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
- 
-
-### Step 2:  Adding OpenTelemetry as a service and configuring exporter options
-
-In your `Program.cs` file, add OpenTelemetry as a service. Here, we are configuring these variables:
-
-`serviceName` - It is the name of your service.
-
-`otlpOptions.Endpoint` - It is the endpoint for your OTel Collector agent.
-
- 
-
-Here’s a sample `Program.cs` file with the configured variables:
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-        resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-                        //sigNoz Cloud Endpoint 
-            otlpOptions.Endpoint = new Uri("https://ingest.{{REGION}}.signoz.cloud:443");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-                        
-                        //SigNoz Cloud account Ingestion key
-            string headerKey = "signoz-ingestion-key";
-            string headerValue = "{{SIGNOZ_INGESTION_KEY}}";
-
-            string formattedHeader = $"{headerKey}={headerValue}";
-            otlpOptions.Headers = formattedHeader;
-        }));
-
-var app = builder.Build();
-
-//The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
-
- 
-
-The OpenTelemetry.Exporter.Options get or set the target to which the exporter is going to send traces. Here, we’re configuring it to send traces to the OTel Collector agent. The target must be a valid Uri with the scheme (http or https) and host and may contain a port and a path.
-
-This is done by configuring an OpenTelemetry [TracerProvider](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/customizing-the-sdk#readme) using extension methods and setting it to auto-start when the host is started.

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/MacOsARM64/QuickStart/dotnet-macosarm64-quickStart-runApplication.md

@@ -1,10 +0,0 @@
- 
-To run your .NET application, use the below command :
-
-```bash
-dotnet build
-dotnet run
-```
-
-Once you run your .NET application, interact with your application to generate some load and see your application in the SigNoz UI.
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/MacOsARM64/Recommended/dotnet-macosarm64-recommended-installOtelCollector.md

@@ -1,98 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
- 
-
-### Step 1: Download otel-collector tar.gz
-```bash
-wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v{{OTEL_VERSION}}/otelcol-contrib_{{OTEL_VERSION}}_darwin_arm64.tar.gz
-```
-
- 
-
-### Step 2: Extract otel-collector tar.gz to the `otelcol-contrib` folder
-```bash
-mkdir otelcol-contrib && tar xvzf otelcol-contrib_{{OTEL_VERSION}}_darwin_arm64.tar.gz -C otelcol-contrib
-```
-
- 
-
-### Step 3: Create `config.yaml` in folder `otelcol-contrib` with the below content in it
-```bash
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: 0.0.0.0:4317
-      http:
-        endpoint: 0.0.0.0:4318
-  hostmetrics:
-    collection_interval: 60s
-    scrapers:
-      cpu: {}
-      disk: {}
-      load: {}
-      filesystem: {}
-      memory: {}
-      network: {}
-      paging: {}
-      process:
-        mute_process_name_error: true
-        mute_process_exe_error: true
-        mute_process_io_error: true
-      processes: {}
-  prometheus:
-    config:
-      global:
-        scrape_interval: 60s
-      scrape_configs:
-        - job_name: otel-collector-binary
-          static_configs:
-            - targets:
-              # - localhost:8888
-processors:
-  batch:
-    send_batch_size: 1000
-    timeout: 10s
-  # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
-  resourcedetection:
-    detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
-    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
-    timeout: 2s
-    system:
-      hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
-extensions:
-  health_check: {}
-  zpages: {}
-exporters:
-  otlp:
-    endpoint: "ingest.{{REGION}}.signoz.cloud:443"
-    tls:
-      insecure: false
-    headers:
-      "signoz-ingestion-key": "{{SIGNOZ_INGESTION_KEY}}"
-  logging:
-    verbosity: normal
-service:
-  telemetry:
-    metrics:
-      address: 0.0.0.0:8888
-  extensions: [health_check, zpages]
-  pipelines:
-    metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    metrics/internal:
-      receivers: [prometheus, hostmetrics]
-      processors: [resourcedetection, batch]
-      exporters: [otlp]
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    logs:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/MacOsARM64/Recommended/dotnet-macosarm64-recommended-instrumentApplication.md

@@ -1,68 +0,0 @@
-After setting up the Otel collector agent, follow the steps below to instrument your .NET Application
-
- 
- 
-
-### Step 1: Install OpenTelemetry Dependencies
-Install the following dependencies in your application.
-
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
- 
-
-### Step 2:  Adding OpenTelemetry as a service and configuring exporter options
-
-In your `Program.cs` file, add OpenTelemetry as a service. Here, we are configuring these variables:
-
-`serviceName` - It is the name of your service.
-
-`otlpOptions.Endpoint` - It is the endpoint for your OTel Collector agent.
-
- 
-
-Here’s a sample `Program.cs` file with the configured variables:
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-        resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-            otlpOptions.Endpoint = new Uri("http://localhost:4317");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-        }));
-
-var app = builder.Build();
-
-//The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
-
- 
-
-The OpenTelemetry.Exporter.Options get or set the target to which the exporter is going to send traces. Here, we’re configuring it to send traces to the OTel Collector agent. The target must be a valid Uri with the scheme (http or https) and host and may contain a port and a path.
-
-This is done by configuring an OpenTelemetry [TracerProvider](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/customizing-the-sdk#readme) using extension methods and setting it to auto-start when the host is started.
-
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/MacOsARM64/Recommended/dotnet-macosarm64-recommended-runApplication.md

@@ -1,18 +0,0 @@
- 
-Once you are done intrumenting your .NET application, you can run it using the below commands
- 
-
-### Step 1: Run OTel Collector
- Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step
-
-```bash
-./otelcol-contrib --config ./config.yaml
-```
-
- 
-
-### Step 2: Run your .NET application
-```bash
-dotnet build
-dotnet run
-```

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Windows/QuickStart/dotnet-windows-quickStart-instrumentApplication.md

@@ -1,67 +0,0 @@
-**Step 1: Installing the OpenTelemetry dependency packages:**
-
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
-**Step 2: Adding OpenTelemetry as a service and configuring exporter options in `Program.cs`:**
-
-In your `Program.cs` file, add OpenTelemetry as a service.
-
-Here’s a sample `Program.cs` file with the configured variables.
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-		resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-						//SigNoz Cloud Endpoint 
-            otlpOptions.Endpoint = new Uri("https://ingest.{{REGION}}.signoz.cloud:443");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-						
-						//SigNoz Cloud account Ingestion key
-            string headerKey = "signoz-ingestion-key";
-            string headerValue = "{{SIGNOZ_INGESTION_KEY}}";
-
-            string formattedHeader = $"{headerKey}={headerValue}";
-            otlpOptions.Headers = formattedHeader;
-        }));
-
-var app = builder.Build();
-
-// The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
-
-
-**Step 3. Running the .NET application:**
-
-```bash
-dotnet build
-dotnet run
-```
-
-**Step 4: Generating some load data and checking your application in SigNoz UI**
-
-Once your application is running, generate some traffic by interacting with it.
-
-In the SigNoz account, open the `Services` tab. Hit the `Refresh` button on the top right corner, and your application should appear in the list of `Applications`. Ensure that you're checking data for the `time range filter` applied in the top right corner. You might have to wait for a few seconds before the data appears on SigNoz UI.

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Windows/QuickStart/dotnet-windows-quickStart-runApplication.md

@@ -1,10 +0,0 @@
- 
-To run your .NET application, use the below command :
-
-```bash
-dotnet build
-dotnet run
-```
-
-Once you run your .NET application, interact with your application to generate some load and see your application in the SigNoz UI.
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Windows/Recommended/dotnet-windows-recommended-installOtelCollector.md

@@ -1,12 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
-
- 
-
-As a first step, you should install the OTel collector Binary according to the instructions provided on [this link](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/).
-
- 
-
-Once you are done setting up the OTel collector binary, you can follow the next steps.
-
- 
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Windows/Recommended/dotnet-windows-recommended-instrumentApplication.md

@@ -1,63 +0,0 @@
-After setting up the Otel collector agent, follow the steps below to instrument your .NET Application
-
- 
- 
-
-### Step 1: Install OpenTelemetry Dependencies
-Install the following dependencies in your application.
-
-```bash
-dotnet add package OpenTelemetry
-dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol 
-dotnet add package OpenTelemetry.Extensions.Hosting
-dotnet add package OpenTelemetry.Instrumentation.Runtime
-dotnet add package OpenTelemetry.Instrumentation.AspNetCore 
-dotnet add package OpenTelemetry.AutoInstrumentation
-```
-
- 
-
-### Step 2:  Adding OpenTelemetry as a service and configuring exporter options
-
-In your `Program.cs` file, add OpenTelemetry as a service. Here, we are configuring these variables:
-
- 
-
-Here’s a sample `Program.cs` file with the configured variables:
-
-```bash
-using System.Diagnostics;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Resources;
-using OpenTelemetry.Trace;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Configure OpenTelemetry with tracing and auto-start.
-builder.Services.AddOpenTelemetry()
-    .ConfigureResource(resource => 
-        resource.AddService(serviceName: "{{MYAPP}}"))
-    .WithTracing(tracing => tracing
-        .AddAspNetCoreInstrumentation()
-        .AddOtlpExporter(otlpOptions =>
-        {
-            otlpOptions.Endpoint = new Uri("http://localhost:4317");
-
-            otlpOptions.Protocol = OtlpExportProtocol.Grpc;
-        }));
-
-var app = builder.Build();
-
-//The index route ("/") is set up to write out the OpenTelemetry trace information on the response:
-app.MapGet("/", () => $"Hello World! OpenTelemetry Trace: {Activity.Current?.Id}");
-
-app.Run();
-```
- 
-
-The OpenTelemetry.Exporter.Options get or set the target to which the exporter is going to send traces. Here, we’re configuring it to send traces to the OTel Collector agent. The target must be a valid Uri with the scheme (http or https) and host and may contain a port and a path.
-
-This is done by configuring an OpenTelemetry [TracerProvider](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/docs/trace/customizing-the-sdk#readme) using extension methods and setting it to auto-start when the host is started.
-
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Dotnet/md-docs/Windows/Recommended/dotnet-windows-recommended-runApplication.md

@@ -1,18 +0,0 @@
- 
-Once you are done intrumenting your .NET application, you can run it using the below commands
- 
-
-### Step 1: Run OTel Collector
- Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step
-
-```bash
-./otelcol-contrib --config ./config.yaml
-```
-
- 
-
-### Step 2: Run your .NET application
-```bash
-dotnet build
-dotnet run
-```

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Docker/QuickStart/elixir-docker-quickStart-instrumentApplication.md

@@ -1,67 +0,0 @@
- 
-
-Follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-  otel_batch_processor: %{
-    exporter: {
-      :opentelemetry_exporter,
-      %{
-        endpoints: ["https://ingest.{{REGION}}.signoz.cloud:443"],
-        headers: [
-          {"signoz-ingestion-key", {{SIGNOZ_ACCESS_TOKEN}} }
-        ]
-      }
-    }
-  }
-```
-
- 
-
-### Step 3: Dockerize your application
-
-Since the environment variables like SIGNOZ_INGESTION_KEY, Ingestion Endpoint and Service name are set in the above steps, you don't need to add any additional steps in your Dockerfile.

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Docker/QuickStart/elixir-docker-quickStart-runApplication.md

@@ -1,25 +0,0 @@
-Once you update your Dockerfile, you can build and run it using the commands below.
-
- 
-
-### Step 1: Build your dockerfile
-
-Build your docker image
-
-```bash
-docker build -t <your-image-name> .
-```
-
-- `<your-image-name>` is the name of your Docker Image
-
-&nbsp;
-
-### Step 2: Run your docker image
-
-```bash
-docker run <your-image-name>
-```
-
-&nbsp;
-
-To see some examples for instrumented applications, you can checkout [this link](https://signoz.io/docs/instrumentation/elixir/#sample-examples)

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Docker/Recommended/elixir-docker-recommended-installOtelCollector.md

@@ -1,12 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
-
- 
-
-As a first step, you should install the OTel collector Binary according to the instructions provided on [this link](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/).
-
- 
-
-Once you are done setting up the OTel collector binary, you can follow the next steps.
-
- 
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Docker/Recommended/elixir-docker-recommended-instrumentApplication.md

@@ -1,61 +0,0 @@
- 
-
-After setting up the Otel collector agent, follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-    otel_batch_processor: %{
-      exporter: 
-      {:opentelemetry_exporter, 
-      %{endpoints: ["http://localhost:4318"]}
-      }
-  }
-```
- 
-
-### Step 3: Dockerize your application
-
-Since the environment variables like SIGNOZ_INGESTION_KEY, Ingestion Endpoint and Service name are set in the above steps, you don't need to add any additional steps in your Dockerfile.

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Docker/Recommended/elixir-docker-recommended-runApplication.md

@@ -1,25 +0,0 @@
-Once you update your Dockerfile, you can build and run it using the commands below.
-
- 
-
-### Step 1: Build your dockerfile
-
-Build your docker image
-
-```bash
-docker build -t <your-image-name> .
-```
-
-- `<your-image-name>` is the name of your Docker Image
-
-&nbsp;
-
-### Step 2: Run your docker image
-
-```bash
-docker run <your-image-name>
-```
-
-&nbsp;
-
-To see some examples for instrumented applications, you can checkout [this link](https://signoz.io/docs/instrumentation/elixir/#sample-examples)

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Kubernetes/elixir-kubernetes-installOtelCollector.md

@@ -1,43 +0,0 @@
-### Install otel-collector in your Kubernetes infra
-
-Add the SigNoz Helm Chart repository
-```bash
-helm repo add signoz https://charts.signoz.io
-```
-
- 
-
-If the chart is already present, update the chart to the latest using:
-```bash
-helm repo update
-```
-
- 
-
-For generic Kubernetes clusters, you can create *override-values.yaml* with the following configuration:
-
-```yaml
-global:
-  cloud: others
-  clusterName: <CLUSTER_NAME>
-  deploymentEnvironment: <DEPLOYMENT_ENVIRONMENT>
-otelCollectorEndpoint: ingest.{{REGION}}.signoz.cloud:443
-otelInsecure: false
-signozApiKey: {{SIGNOZ_INGESTION_KEY}}
-presets:
-  otlpExporter:
-    enabled: true
-  loggingExporter:
-    enabled: false
-```
-
-- Replace `<CLUSTER_NAME>` with the name of the Kubernetes cluster or a unique identifier of the cluster.
-- Replace `<DEPLOYMENT_ENVIRONMENT>` with the deployment environment of your application. Example: **"staging"**, **"production"**, etc.
-
-&nbsp;
-
-To install the k8s-infra chart with the above configuration, run the following command:
-
-```bash
-helm install my-release signoz/k8s-infra -f override-values.yaml
-```

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Kubernetes/elixir-kubernetes-instrumentApplication.md

@@ -1,57 +0,0 @@
- 
-
-After setting up the Otel collector agent, follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-    otel_batch_processor: %{
-      exporter: 
-      {:opentelemetry_exporter, 
-      %{endpoints: ["http://localhost:4318"]}
-      }
-  }
-```
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Kubernetes/elixir-kubernetes-runApplication.md

@@ -1,6 +0,0 @@
-### Running your Elixir application
-Once you are done instrumenting your Elixir (Phoenix + Ecto) application with OpenTelemetry, you should install the dependencies needed to run your application and run it as you normally would.
-
- 
-
-To see some examples for instrumented applications, you can checkout [this link](https://signoz.io/docs/instrumentation/elixir/#sample-examples)

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/LinuxAMD64/QuickStart/elixir-linuxamd64-quickStart-instrumentApplication.md

@@ -1,62 +0,0 @@
- 
-
-Follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-  otel_batch_processor: %{
-    exporter: {
-      :opentelemetry_exporter,
-      %{
-        endpoints: ["https://ingest.{{REGION}}.signoz.cloud:443"],
-        headers: [
-          {"signoz-ingestion-key", {{SIGNOZ_ACCESS_TOKEN}} }
-        ]
-      }
-    }
-  }
-```
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/LinuxAMD64/QuickStart/elixir-linuxamd64-quickStart-runApplication.md

@@ -1,6 +0,0 @@
-### Running your Elixir application
-Once you are done instrumenting your Elixir (Phoenix + Ecto) application with OpenTelemetry, you should install the dependencies needed to run your application and run it as you normally would.
-
- 
-
-To see some examples for instrumented applications, you can checkout [this link](https://signoz.io/docs/instrumentation/elixir/#sample-examples)

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/LinuxAMD64/Recommended/elixir-linuxamd64-recommended-installOtelCollector.md

@@ -1,96 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
- 
-
-### Step 1: Download otel-collector tar.gz
-```bash
-wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v{{OTEL_VERSION}}/otelcol-contrib_{{OTEL_VERSION}}_linux_amd64.tar.gz
-```
- 
-
-### Step 2: Extract otel-collector tar.gz to the `otelcol-contrib` folder
-```bash
-mkdir otelcol-contrib && tar xvzf otelcol-contrib_{{OTEL_VERSION}}_linux_amd64.tar.gz -C otelcol-contrib
-```
- 
-
-### Step 3: Create config.yaml in folder otelcol-contrib with the below content in it
-```bash
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: 0.0.0.0:4317
-      http:
-        endpoint: 0.0.0.0:4318
-  hostmetrics:
-    collection_interval: 60s
-    scrapers:
-      cpu: {}
-      disk: {}
-      load: {}
-      filesystem: {}
-      memory: {}
-      network: {}
-      paging: {}
-      process:
-        mute_process_name_error: true
-        mute_process_exe_error: true
-        mute_process_io_error: true
-      processes: {}
-  prometheus:
-    config:
-      global:
-        scrape_interval: 60s
-      scrape_configs:
-        - job_name: otel-collector-binary
-          static_configs:
-            - targets:
-              # - localhost:8888
-processors:
-  batch:
-    send_batch_size: 1000
-    timeout: 10s
-  # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
-  resourcedetection:
-    detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
-    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
-    timeout: 2s
-    system:
-      hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
-extensions:
-  health_check: {}
-  zpages: {}
-exporters:
-  otlp:
-    endpoint: "ingest.{{REGION}}.signoz.cloud:443"
-    tls:
-      insecure: false
-    headers:
-      "signoz-ingestion-key": "{{SIGNOZ_INGESTION_KEY}}"
-  logging:
-    verbosity: normal
-service:
-  telemetry:
-    metrics:
-      address: 0.0.0.0:8888
-  extensions: [health_check, zpages]
-  pipelines:
-    metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    metrics/internal:
-      receivers: [prometheus, hostmetrics]
-      processors: [resourcedetection, batch]
-      exporters: [otlp]
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    logs:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/LinuxAMD64/Recommended/elixir-linuxamd64-recommended-instrumentApplication.md

@@ -1,57 +0,0 @@
- 
-
-After setting up the Otel collector agent, follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-    otel_batch_processor: %{
-      exporter: 
-      {:opentelemetry_exporter, 
-      %{endpoints: ["http://localhost:4318"]}
-      }
-  }
-```
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/LinuxAMD64/Recommended/elixir-linuxamd64-recommended-runApplication.md

@@ -1,29 +0,0 @@
- 
-
-### Step 1: Run OTel Collector
- Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step
-
-```bash
-./otelcol-contrib --config ./config.yaml &> otelcol-output.log & echo "$!" > otel-pid
-```
- 
-
-#### (Optional Step): View last 50 lines of `otelcol` logs
-```bash
-tail -f -n 50 otelcol-output.log
-```
-
-#### (Optional Step): Stop `otelcol`
-```bash
-kill "$(< otel-pid)"
-```
-&nbsp;
-
-### Step 2: Running your Elixir application
-
-Once you are done instrumenting your Elixir (Phoenix + Ecto) application with OpenTelemetry, you should install the dependencies needed to run your application and run it as you normally would.
-
-&nbsp;
-
-To see some examples for instrumented applications, you can checkout [this link](https://signoz.io/docs/instrumentation/elixir/#sample-examples)
-```

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/LinuxARM64/QuickStart/elixir-linuxarm64-quickStart-instrumentApplication.md

@@ -1,62 +0,0 @@
- 
-
-Follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-  otel_batch_processor: %{
-    exporter: {
-      :opentelemetry_exporter,
-      %{
-        endpoints: ["https://ingest.{{REGION}}.signoz.cloud:443"],
-        headers: [
-          {"signoz-ingestion-key", {{SIGNOZ_ACCESS_TOKEN}} }
-        ]
-      }
-    }
-  }
-```
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/LinuxARM64/QuickStart/elixir-linuxarm64-quickStart-runApplication.md

@@ -1,6 +0,0 @@
-### Running your Elixir application
-Once you are done instrumenting your Elixir (Phoenix + Ecto) application with OpenTelemetry, you should install the dependencies needed to run your application and run it as you normally would.
-
- 
-
-To see some examples for instrumented applications, you can checkout [this link](https://signoz.io/docs/instrumentation/elixir/#sample-examples)

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/LinuxARM64/Recommended/elixir-linuxarm64-recommended-installOtelCollector.md

@@ -1,96 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
- 
-
-### Step 1: Download otel-collector tar.gz
-```bash
-wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v{{OTEL_VERSION}}/otelcol-contrib_{{OTEL_VERSION}}_linux_arm64.tar.gz
-```
- 
-
-### Step 2: Extract otel-collector tar.gz to the `otelcol-contrib` folder
-```bash
-mkdir otelcol-contrib && tar xvzf otelcol-contrib_{{OTEL_VERSION}}_linux_arm64.tar.gz -C otelcol-contrib
-```
- 
-
-### Step 3: Create config.yaml in folder otelcol-contrib with the below content in it
-```bash
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: 0.0.0.0:4317
-      http:
-        endpoint: 0.0.0.0:4318
-  hostmetrics:
-    collection_interval: 60s
-    scrapers:
-      cpu: {}
-      disk: {}
-      load: {}
-      filesystem: {}
-      memory: {}
-      network: {}
-      paging: {}
-      process:
-        mute_process_name_error: true
-        mute_process_exe_error: true
-        mute_process_io_error: true
-      processes: {}
-  prometheus:
-    config:
-      global:
-        scrape_interval: 60s
-      scrape_configs:
-        - job_name: otel-collector-binary
-          static_configs:
-            - targets:
-              # - localhost:8888
-processors:
-  batch:
-    send_batch_size: 1000
-    timeout: 10s
-  # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
-  resourcedetection:
-    detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
-    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
-    timeout: 2s
-    system:
-      hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
-extensions:
-  health_check: {}
-  zpages: {}
-exporters:
-  otlp:
-    endpoint: "ingest.{{REGION}}.signoz.cloud:443"
-    tls:
-      insecure: false
-    headers:
-      "signoz-ingestion-key": "{{SIGNOZ_INGESTION_KEY}}"
-  logging:
-    verbosity: normal
-service:
-  telemetry:
-    metrics:
-      address: 0.0.0.0:8888
-  extensions: [health_check, zpages]
-  pipelines:
-    metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    metrics/internal:
-      receivers: [prometheus, hostmetrics]
-      processors: [resourcedetection, batch]
-      exporters: [otlp]
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    logs:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/LinuxARM64/Recommended/elixir-linuxarm64-recommended-instrumentApplication.md

@@ -1,57 +0,0 @@
- 
-
-After setting up the Otel collector agent, follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-    otel_batch_processor: %{
-      exporter: 
-      {:opentelemetry_exporter, 
-      %{endpoints: ["http://localhost:4318"]}
-      }
-  }
-```
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/LinuxARM64/Recommended/elixir-linuxarm64-recommended-runApplication.md

@@ -1,28 +0,0 @@
- 
-
-### Step 1: Run OTel Collector
- Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step
-
-```bash
-./otelcol-contrib --config ./config.yaml &> otelcol-output.log & echo "$!" > otel-pid
-```
- 
-
-#### (Optional Step): View last 50 lines of `otelcol` logs
-```bash
-tail -f -n 50 otelcol-output.log
-```
-
-#### (Optional Step): Stop `otelcol`
-```bash
-kill "$(< otel-pid)"
-```
-&nbsp;
-
-### Step 2: Running your Elixir application
-Once you are done instrumenting your Elixir (Phoenix + Ecto) application with OpenTelemetry, you should install the dependencies needed to run your application and run it as you normally would.
-
-&nbsp;
-
-To see some examples for instrumented applications, you can checkout [this link](https://signoz.io/docs/instrumentation/elixir/#sample-examples)
-```

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/MacOsAMD64/QuickStart/elixir-macosamd64-quickStart-instrumentApplication.md

@@ -1,62 +0,0 @@
- 
-
-Follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-  otel_batch_processor: %{
-    exporter: {
-      :opentelemetry_exporter,
-      %{
-        endpoints: ["https://ingest.{{REGION}}.signoz.cloud:443"],
-        headers: [
-          {"signoz-ingestion-key", {{SIGNOZ_ACCESS_TOKEN}} }
-        ]
-      }
-    }
-  }
-```
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/MacOsAMD64/QuickStart/elixir-macosamd64-quickStart-runApplication.md

@@ -1,6 +0,0 @@
-### Running your Elixir application
-Once you are done instrumenting your Elixir (Phoenix + Ecto) application with OpenTelemetry, you should install the dependencies needed to run your application and run it as you normally would.
-
- 
-
-To see some examples for instrumented applications, you can checkout [this link](https://signoz.io/docs/instrumentation/elixir/#sample-examples)

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/MacOsAMD64/Recommended/elixir-macosamd64-recommended-installOtelCollector.md

@@ -1,96 +0,0 @@
-### Setup OpenTelemetry Binary as an agent
- 
-
-### Step 1: Download otel-collector tar.gz
-```bash
-wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v{{OTEL_VERSION}}/otelcol-contrib_{{OTEL_VERSION}}_darwin_amd64.tar.gz
-```
- 
-
-### Step 2: Extract otel-collector tar.gz to the `otelcol-contrib` folder
-```bash
-mkdir otelcol-contrib && tar xvzf otelcol-contrib_{{OTEL_VERSION}}_darwin_amd64.tar.gz -C otelcol-contrib
-```
- 
-
-### Step 3: Create config.yaml in folder otelcol-contrib with the below content in it
-```bash
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: 0.0.0.0:4317
-      http:
-        endpoint: 0.0.0.0:4318
-  hostmetrics:
-    collection_interval: 60s
-    scrapers:
-      cpu: {}
-      disk: {}
-      load: {}
-      filesystem: {}
-      memory: {}
-      network: {}
-      paging: {}
-      process:
-        mute_process_name_error: true
-        mute_process_exe_error: true
-        mute_process_io_error: true
-      processes: {}
-  prometheus:
-    config:
-      global:
-        scrape_interval: 60s
-      scrape_configs:
-        - job_name: otel-collector-binary
-          static_configs:
-            - targets:
-              # - localhost:8888
-processors:
-  batch:
-    send_batch_size: 1000
-    timeout: 10s
-  # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
-  resourcedetection:
-    detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
-    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
-    timeout: 2s
-    system:
-      hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
-extensions:
-  health_check: {}
-  zpages: {}
-exporters:
-  otlp:
-    endpoint: "ingest.{{REGION}}.signoz.cloud:443"
-    tls:
-      insecure: false
-    headers:
-      "signoz-ingestion-key": "{{SIGNOZ_INGESTION_KEY}}"
-  logging:
-    verbosity: normal
-service:
-  telemetry:
-    metrics:
-      address: 0.0.0.0:8888
-  extensions: [health_check, zpages]
-  pipelines:
-    metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    metrics/internal:
-      receivers: [prometheus, hostmetrics]
-      processors: [resourcedetection, batch]
-      exporters: [otlp]
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    logs:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/MacOsAMD64/Recommended/elixir-macosamd64-recommended-instrumentApplication.md

@@ -1,57 +0,0 @@
- 
-
-After setting up the Otel collector agent, follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-    otel_batch_processor: %{
-      exporter: 
-      {:opentelemetry_exporter, 
-      %{endpoints: ["http://localhost:4318"]}
-      }
-  }
-```
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/MacOsAMD64/Recommended/elixir-macosamd64-recommended-runApplication.md

@@ -1,28 +0,0 @@
- 
-
-### Step 1: Run OTel Collector
- Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step
-
-```bash
-./otelcol-contrib --config ./config.yaml &> otelcol-output.log & echo "$!" > otel-pid
-```
- 
-
-#### (Optional Step): View last 50 lines of `otelcol` logs
-```bash
-tail -f -n 50 otelcol-output.log
-```
-
-#### (Optional Step): Stop `otelcol`
-```bash
-kill "$(< otel-pid)"
-```
-&nbsp;
-
-### Step 2: Running your Elixir application
-Once you are done instrumenting your Elixir (Phoenix + Ecto) application with OpenTelemetry, you should install the dependencies needed to run your application and run it as you normally would.
-
-&nbsp;
-
-To see some examples for instrumented applications, you can checkout [this link](https://signoz.io/docs/instrumentation/elixir/#sample-examples)
-```

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/MacOsARM64/QuickStart/elixir-macosarm64-quickStart-instrumentApplication.md

@@ -1,62 +0,0 @@
- 
-
-Follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-  otel_batch_processor: %{
-    exporter: {
-      :opentelemetry_exporter,
-      %{
-        endpoints: ["https://ingest.{{REGION}}.signoz.cloud:443"],
-        headers: [
-          {"signoz-ingestion-key", {{SIGNOZ_ACCESS_TOKEN}} }
-        ]
-      }
-    }
-  }
-```
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/MacOsARM64/QuickStart/elixir-macosarm64-quickStart-runApplication.md

@@ -1,6 +0,0 @@
-### Running your Elixir application
-Once you are done instrumenting your Elixir (Phoenix + Ecto) application with OpenTelemetry, you should install the dependencies needed to run your application and run it as you normally would.
-
- 
-
-To see some examples for instrumented applications, you can checkout [this link](https://signoz.io/docs/instrumentation/elixir/#sample-examples)

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/MacOsARM64/Recommended/elixir-macosarm64-recommended-installOtelCollector.md

@@ -1,96 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
- 
-
-### Step 1: Download otel-collector tar.gz
-```bash
-wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v{{OTEL_VERSION}}/otelcol-contrib_{{OTEL_VERSION}}_darwin_arm64.tar.gz
-```
- 
-
-### Step 2: Extract otel-collector tar.gz to the `otelcol-contrib` folder
-```bash
-mkdir otelcol-contrib && tar xvzf otelcol-contrib_{{OTEL_VERSION}}_darwin_arm64.tar.gz -C otelcol-contrib
-```
- 
-
-### Step 3: Create config.yaml in folder otelcol-contrib with the below content in it
-```bash
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: 0.0.0.0:4317
-      http:
-        endpoint: 0.0.0.0:4318
-  hostmetrics:
-    collection_interval: 60s
-    scrapers:
-      cpu: {}
-      disk: {}
-      load: {}
-      filesystem: {}
-      memory: {}
-      network: {}
-      paging: {}
-      process:
-        mute_process_name_error: true
-        mute_process_exe_error: true
-        mute_process_io_error: true
-      processes: {}
-  prometheus:
-    config:
-      global:
-        scrape_interval: 60s
-      scrape_configs:
-        - job_name: otel-collector-binary
-          static_configs:
-            - targets:
-              # - localhost:8888
-processors:
-  batch:
-    send_batch_size: 1000
-    timeout: 10s
-  # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
-  resourcedetection:
-    detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
-    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
-    timeout: 2s
-    system:
-      hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
-extensions:
-  health_check: {}
-  zpages: {}
-exporters:
-  otlp:
-    endpoint: "ingest.{{REGION}}.signoz.cloud:443"
-    tls:
-      insecure: false
-    headers:
-      "signoz-ingestion-key": "{{SIGNOZ_INGESTION_KEY}}"
-  logging:
-    verbosity: normal
-service:
-  telemetry:
-    metrics:
-      address: 0.0.0.0:8888
-  extensions: [health_check, zpages]
-  pipelines:
-    metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    metrics/internal:
-      receivers: [prometheus, hostmetrics]
-      processors: [resourcedetection, batch]
-      exporters: [otlp]
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    logs:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/MacOsARM64/Recommended/elixir-macosarm64-recommended-instrumentApplication.md

@@ -1,57 +0,0 @@
- 
-
-After setting up the Otel collector agent, follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-    otel_batch_processor: %{
-      exporter: 
-      {:opentelemetry_exporter, 
-      %{endpoints: ["http://localhost:4318"]}
-      }
-  }
-```
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/MacOsARM64/Recommended/elixir-macosarm64-recommended-runApplication.md

@@ -1,28 +0,0 @@
- 
-
-### Step 1: Run OTel Collector
- Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step
-
-```bash
-./otelcol-contrib --config ./config.yaml &> otelcol-output.log & echo "$!" > otel-pid
-```
- 
-
-#### (Optional Step): View last 50 lines of `otelcol` logs
-```bash
-tail -f -n 50 otelcol-output.log
-```
-
-#### (Optional Step): Stop `otelcol`
-```bash
-kill "$(< otel-pid)"
-```
-&nbsp;
-
-### Step 2: Running your Elixir application
-Once you are done instrumenting your Elixir (Phoenix + Ecto) application with OpenTelemetry, you should install the dependencies needed to run your application and run it as you normally would.
-
-&nbsp;
-
-To see some examples for instrumented applications, you can checkout [this link](https://signoz.io/docs/instrumentation/elixir/#sample-examples)
-```

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Windows/QuickStart/elixir-windows-quickStart-instrumentApplication.md

@@ -1,62 +0,0 @@
- 
-
-Follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-  otel_batch_processor: %{
-    exporter: {
-      :opentelemetry_exporter,
-      %{
-        endpoints: ["https://ingest.{{REGION}}.signoz.cloud:443"],
-        headers: [
-          {"signoz-ingestion-key", {{SIGNOZ_ACCESS_TOKEN}} }
-        ]
-      }
-    }
-  }
-```
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Windows/QuickStart/elixir-windows-quickStart-runApplication.md

@@ -1,6 +0,0 @@
-### Running your Elixir application
-Once you are done instrumenting your Elixir (Phoenix + Ecto) application with OpenTelemetry, you should install the dependencies needed to run your application and run it as you normally would.
-
- 
-
-To see some examples for instrumented applications, you can checkout [this link](https://signoz.io/docs/instrumentation/elixir/#sample-examples)

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Windows/Recommended/elixir-windows-recommended-installOtelCollector.md

@@ -1,105 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
- 
-
-### Step 1: Download otel-collector tar.gz
-
- 
-
-```bash
-wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v{{OTEL_VERSION}}/otelcol-contrib_{{OTEL_VERSION}}_linux_amd64.tar.gz
-```
- 
-
-### Step 2: Extract otel-collector tar.gz to the `otelcol-contrib` folder
-
- 
-
-```bash
-mkdir otelcol-contrib && tar xvzf otelcol-contrib_{{OTEL_VERSION}}_linux_amd64.tar.gz -C otelcol-contrib
-```
- 
-
-### Step 3: Create config.yaml in folder otelcol-contrib with the below content in it
-
- 
-
-```bash
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: 0.0.0.0:4317
-      http:
-        endpoint: 0.0.0.0:4318
-  hostmetrics:
-    collection_interval: 60s
-    scrapers:
-      cpu: {}
-      disk: {}
-      load: {}
-      filesystem: {}
-      memory: {}
-      network: {}
-      paging: {}
-      process:
-        mute_process_name_error: true
-        mute_process_exe_error: true
-        mute_process_io_error: true
-      processes: {}
-  prometheus:
-    config:
-      global:
-        scrape_interval: 60s
-      scrape_configs:
-        - job_name: otel-collector-binary
-          static_configs:
-            - targets:
-              # - localhost:8888
-processors:
-  batch:
-    send_batch_size: 1000
-    timeout: 10s
-  # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
-  resourcedetection:
-    detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
-    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
-    timeout: 2s
-    system:
-      hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
-extensions:
-  health_check: {}
-  zpages: {}
-exporters:
-  otlp:
-    endpoint: "ingest.{{REGION}}.signoz.cloud:443"
-    tls:
-      insecure: false
-    headers:
-      "signoz-ingestion-key": "{{SIGNOZ_INGESTION_KEY}}"
-  logging:
-    verbosity: normal
-service:
-  telemetry:
-    metrics:
-      address: 0.0.0.0:8888
-  extensions: [health_check, zpages]
-  pipelines:
-    metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    metrics/internal:
-      receivers: [prometheus, hostmetrics]
-      processors: [resourcedetection, batch]
-      exporters: [otlp]
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    logs:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Windows/Recommended/elixir-windows-recommended-instrumentApplication.md

@@ -1,57 +0,0 @@
- 
-
-After setting up the Otel collector agent, follow the steps below to instrument your Elixir (Phoenix + Ecto) Application
-
-### Step 1: Add dependencies
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file 
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
- 
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers 
-
-```bash
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:{{MYAPP}}, :repo])
-```
- 
-
-As an example, this is how you can setup the handlers in your application.ex file for an application called demo :
-
-```bash
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
- 
-
-### Step 2: Configure Application
-You need to configure your application to send telemetry data by adding the following config to your `runtime.exs` file:
-
-```bash
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-    otel_batch_processor: %{
-      exporter: 
-      {:opentelemetry_exporter, 
-      %{endpoints: ["http://localhost:4318"]}
-      }
-  }
-```
-

frontend/src/container/OnboardingContainer/Modules/APM/Elixir/md-docs/Windows/Recommended/elixir-windows-recommended-runApplication.md

@@ -1,55 +0,0 @@
-
-OTel Collector binary helps to collect logs, hostmetrics, resource and infra attributes. It is recommended to install Otel Collector binary to collect and send traces to SigNoz cloud. You can correlate signals and have rich contextual data through this way.
-
-You can find instructions to install OTel Collector binary [here](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/) in your VM. Once you are done setting up your OTel Collector binary, you can follow the below steps for instrumenting your Elixir (Phoenix + Ecto) application.
-
-**Step 1. Add dependencies**
-
-Install dependencies related to OpenTelemetry by adding them to `mix.exs` file
-
-```bash
-    {:opentelemetry_exporter, "~> 1.6"},
-    {:opentelemetry_api, "~> 1.2"},
-    {:opentelemetry, "~> 1.3"},
-    {:opentelemetry_semantic_conventions, "~> 0.2"},
-    {:opentelemetry_cowboy, "~> 0.2.1"},
-    {:opentelemetry_phoenix, "~> 1.1"},
-    {:opentelemetry_ecto, "~> 1.1"}
-```
-
-In your application start, usually the `application.ex` file, setup the telemetry handlers
-
-```elixir
-    :opentelemetry_cowboy.setup()
-    OpentelemetryPhoenix.setup(adapter: :cowboy2)
-    OpentelemetryEcto.setup([:YOUR_APP_NAME, :repo])
-```
-
-As an example, this is how you can setup the handlers in your `application.ex` file for an application called `demo` :
-
-```elixir
-# application.ex
-@impl true
-def start(_type, _args) do
-  :opentelemetry_cowboy.setup()
-  OpentelemetryPhoenix.setup(adapter: :cowboy2)
-  OpentelemetryEcto.setup([:demo, :repo])
-
-end
-```
-
-**Step 2. Configure Application**
-
-You need to configure your application to send telemtry data by adding the follwing config to your `runtime.exs` file:
-
-```elixir
-config :opentelemetry, :resource, service: %{name: "{{MYAPP}}"}
-
-config :opentelemetry, :processors,
-    otel_batch_processor: %{
-      exporter: 
-      {:opentelemetry_exporter, 
-      %{endpoints: ["http://localhost:4318"]}
-      }
-  }
-```

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/goLang.md

@@ -1,414 +0,0 @@
-## Send Traces to SigNoz Cloud
-
-### Application on VMs
-
-From VMs, there are two ways to send data to SigNoz Cloud.
-
-- Send traces directly to SigNoz Cloud (quick start)
-- Send traces via OTel Collector binary (recommended)
-
-#### **Send traces directly to SigNoz Cloud**
-
-1. **Install Dependencies**
-   
-   Dependencies related to OpenTelemetry exporter and SDK have to be installed first. Note that we are assuming you are using `gin` request router. If you are using other request routers, check out the [corresponding package](https://signoz.io/docs/instrumentation/golang/#request-routers).
-   
-   Run the below commands after navigating to the application source folder:
-    
-    ```bash
-    go get go.opentelemetry.io/otel \
-      go.opentelemetry.io/otel/trace \
-      go.opentelemetry.io/otel/sdk \
-      go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin \
-      go.opentelemetry.io/otel/exporters/otlp/otlptrace \
-      go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
-    ```
-    
-2. **Declare environment variables for configuring OpenTelemetry**
-   
-   Declare the following global variables in `main.go` which we will use to configure OpenTelemetry:
-   
-   ```bash
-    var (
-        serviceName  = os.Getenv("SERVICE_NAME")
-        collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-        insecure     = os.Getenv("INSECURE_MODE")
-    )
-    ```
-    
-3. **Instrument your Go application with OpenTelemetry**
-   
-   To configure your application to send data we will need a function to initialize OpenTelemetry. Add the following snippet of code in your `main.go` file.
-   
-    ```go
-        
-    import (
-        .....
-
-        "github.com/gin-gonic/gin"
-        "go.opentelemetry.io/otel"
-        "go.opentelemetry.io/otel/attribute"
-        "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
-        "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-
-        "go.opentelemetry.io/otel/sdk/resource"
-        sdktrace "go.opentelemetry.io/otel/sdk/trace"
-    )
-
-    func initTracer() func(context.Context) error {
-
-        var secureOption otlptracegrpc.Option
-
-        if strings.ToLower(insecure) == "false" || insecure == "0" || strings.ToLower(insecure) == "f" {
-            secureOption = otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
-        } else {
-            secureOption = otlptracegrpc.WithInsecure()
-        }
-
-        exporter, err := otlptrace.New(
-            context.Background(),
-            otlptracegrpc.NewClient(
-                secureOption,
-                otlptracegrpc.WithEndpoint(collectorURL),
-            ),
-        )
-
-        if err != nil {
-            log.Fatalf("Failed to create exporter: %v", err)
-        }
-        resources, err := resource.New(
-            context.Background(),
-            resource.WithAttributes(
-                attribute.String("service.name", serviceName),
-                attribute.String("library.language", "go"),
-            ),
-        )
-        if err != nil {
-            log.Fatalf("Could not set resources: %v", err)
-        }
-
-        otel.SetTracerProvider(
-            sdktrace.NewTracerProvider(
-                sdktrace.WithSampler(sdktrace.AlwaysSample()),
-                sdktrace.WithBatcher(exporter),
-                sdktrace.WithResource(resources),
-            ),
-        )
-        return exporter.Shutdown
-    }
-    ```
-    
-4. **Initialize the tracer in main.go**
-   
-   Modify the main function to initialise the tracer in `main.go`. Initiate the tracer at the very beginning of our main function.
-    
-    ```go
-    func main() {
-        cleanup := initTracer()
-        defer cleanup(context.Background())
-    
-        ......
-    }
-    ```
-    
-5. **Add the OpenTelemetry Gin middleware**
-   
-   Configure Gin to use the middleware by adding the following lines in `main.go`.
-    
-    ```go
-    import (
-        ....
-      "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
-    )
-    
-    func main() {
-        ......
-        r := gin.Default()
-        r.Use(otelgin.Middleware(serviceName))
-        ......
-    }
-    ```
-
-6. **Set environment variables and run your Go Gin application**
-   
-   The run command must have some environment variables to send data to SigNoz cloud. The run command:
-    
-    ```bash
-    SERVICE_NAME={{MYAPP}} INSECURE_MODE=false OTEL_EXPORTER_OTLP_HEADERS=signoz-ingestion-key={{SIGNOZ_INGESTION_KEY}} OTEL_EXPORTER_OTLP_ENDPOINT=ingest.{{REGION}}.signoz.cloud:443 go run main.go
-    ```  
-    
-    If you want to update your `service_name`, you can modify the `SERVICE_NAME` variable.
-  
----
-
-#### **Send traces via OTel Collector binary**
-
-OTel Collector binary helps to collect logs, hostmetrics, resource and infra attributes. It is recommended to install Otel Collector binary to collect and send traces to SigNoz cloud. You can correlate signals and have rich contextual data through this way.
-
-You can find instructions to install OTel Collector binary [here](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/) in your VM. Once you are done setting up your OTel Collector binary, you can follow the below steps for instrumenting your Golang application.
-
-1. **Install Dependencies**
-   
-   Dependencies related to OpenTelemetry exporter and SDK have to be installed first. Note that we are assuming you are using `gin` request router. If you are using other request routers, check out the [corresponding package](https://signoz.io/docs/instrumentation/golang/#request-routers).
-   
-   Run the below commands after navigating to the application source folder:
-    
-    ```bash
-    go get go.opentelemetry.io/otel \
-      go.opentelemetry.io/otel/trace \
-      go.opentelemetry.io/otel/sdk \
-      go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin \
-      go.opentelemetry.io/otel/exporters/otlp/otlptrace \
-      go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
-    ```
-    
-2. **Declare environment variables for configuring OpenTelemetry**
-   
-   Declare the following global variables in `main.go` which we will use to configure OpenTelemetry:
-   
-   ```go
-    var (
-        serviceName  = os.Getenv("SERVICE_NAME")
-        collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-        insecure     = os.Getenv("INSECURE_MODE")
-    )
-    ```
-    
-3. **Instrument your Go application with OpenTelemetry**
-   
-   To configure your application to send data we will need a function to initialize OpenTelemetry. Add the following snippet of code in your `main.go` file.
-    
-   ```go
-        
-    import (
-        .....
-
-        "github.com/gin-gonic/gin"
-        "go.opentelemetry.io/otel"
-        "go.opentelemetry.io/otel/attribute"
-        "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
-        "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-
-        "go.opentelemetry.io/otel/sdk/resource"
-        sdktrace "go.opentelemetry.io/otel/sdk/trace"
-    )
-
-    func initTracer() func(context.Context) error {
-
-        var secureOption otlptracegrpc.Option
-
-        if strings.ToLower(insecure) == "false" || insecure == "0" || strings.ToLower(insecure) == "f" {
-            secureOption = otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
-        } else {
-            secureOption = otlptracegrpc.WithInsecure()
-        }
-
-        exporter, err := otlptrace.New(
-            context.Background(),
-            otlptracegrpc.NewClient(
-                secureOption,
-                otlptracegrpc.WithEndpoint(collectorURL),
-            ),
-        )
-
-        if err != nil {
-            log.Fatalf("Failed to create exporter: %v", err)
-        }
-        resources, err := resource.New(
-            context.Background(),
-            resource.WithAttributes(
-                attribute.String("service.name", serviceName),
-                attribute.String("library.language", "go"),
-            ),
-        )
-        if err != nil {
-            log.Fatalf("Could not set resources: %v", err)
-        }
-
-        otel.SetTracerProvider(
-            sdktrace.NewTracerProvider(
-                sdktrace.WithSampler(sdktrace.AlwaysSample()),
-                sdktrace.WithBatcher(exporter),
-                sdktrace.WithResource(resources),
-            ),
-        )
-        return exporter.Shutdown
-    }
-    
-4. **Initialize the tracer in main.go**
-   
-   Modify the main function to initialise the tracer in `main.go`. Initiate the tracer at the very beginning of our main function.
-    
-    ```go
-    func main() {
-        cleanup := initTracer()
-        defer cleanup(context.Background())
-    
-        ......
-    }
-    ```
-    
-5. **Add the OpenTelemetry Gin middleware**
-   
-   Configure Gin to use the middleware by adding the following lines in `main.go`.
-    
-    ```go
-    import (
-        ....
-      "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
-    )
-    
-    func main() {
-        ......
-        r := gin.Default()
-        r.Use(otelgin.Middleware(serviceName))
-        ......
-    }
-    ```
-    
-6. **Set environment variables and run your Go Gin application**
-   
-   The run command must have some environment variables to send data to SigNoz. The run command:
-    
-    ```bash
-    SERVICE_NAME={{MYAPP}} INSECURE_MODE=true OTEL_EXPORTER_OTLP_ENDPOINT=localhost:4317 go run main.go
-    ```
-    
-    If you want to update your `service_name`, you can modify the `SERVICE_NAME` variable.
-
----
-
-### Applications Deployed on Kubernetes
-
-For Golang application deployed on Kubernetes, you need to install OTel Collector agent in your k8s infra to collect and send traces to SigNoz Cloud. You can find the instructions to install OTel Collector agent [here](https://signoz.io/docs/tutorial/kubernetes-infra-metrics/).
-
-Once you have set up OTel Collector agent, you can proceed with OpenTelemetry Golang instrumentation by following the below steps:
-
-1. **Install Dependencies**
-   
-   Dependencies related to OpenTelemetry exporter and SDK have to be installed first. Note that we are assuming you are using `gin` request router. If you are using other request routers, check out the [corresponding package](https://signoz.io/docs/instrumentation/golang/#request-routers).
-   
-   Run the below commands after navigating to the application source folder:
-    
-    ```bash
-    go get go.opentelemetry.io/otel \
-      go.opentelemetry.io/otel/trace \
-      go.opentelemetry.io/otel/sdk \
-      go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin \
-      go.opentelemetry.io/otel/exporters/otlp/otlptrace \
-      go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
-    ```
-    
-2. **Declare environment variables for configuring OpenTelemetry**
-   
-   Declare the following global variables in `main.go` which we will use to configure OpenTelemetry:
-   
-   ```go
-    var (
-        serviceName  = os.Getenv("SERVICE_NAME")
-        collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-        insecure     = os.Getenv("INSECURE_MODE")
-    )
-    ```
-    
-3. **Instrument your Go application with OpenTelemetry**
-   
-   To configure your application to send data we will need a function to initialize OpenTelemetry. Add the following snippet of code in your `main.go` file.
-    
-   ```go
-        
-    import (
-        .....
-
-        "github.com/gin-gonic/gin"
-        "go.opentelemetry.io/otel"
-        "go.opentelemetry.io/otel/attribute"
-        "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
-        "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-
-        "go.opentelemetry.io/otel/sdk/resource"
-        sdktrace "go.opentelemetry.io/otel/sdk/trace"
-    )
-
-    func initTracer() func(context.Context) error {
-
-        var secureOption otlptracegrpc.Option
-
-        if strings.ToLower(insecure) == "false" || insecure == "0" || strings.ToLower(insecure) == "f" {
-            secureOption = otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
-        } else {
-            secureOption = otlptracegrpc.WithInsecure()
-        }
-
-        exporter, err := otlptrace.New(
-            context.Background(),
-            otlptracegrpc.NewClient(
-                secureOption,
-                otlptracegrpc.WithEndpoint(collectorURL),
-            ),
-        )
-
-        if err != nil {
-            log.Fatalf("Failed to create exporter: %v", err)
-        }
-        resources, err := resource.New(
-            context.Background(),
-            resource.WithAttributes(
-                attribute.String("service.name", serviceName),
-                attribute.String("library.language", "go"),
-            ),
-        )
-        if err != nil {
-            log.Fatalf("Could not set resources: %v", err)
-        }
-
-        otel.SetTracerProvider(
-            sdktrace.NewTracerProvider(
-                sdktrace.WithSampler(sdktrace.AlwaysSample()),
-                sdktrace.WithBatcher(exporter),
-                sdktrace.WithResource(resources),
-            ),
-        )
-        return exporter.Shutdown
-    }
-    
-4. **Initialize the tracer in main.go**
-   
-   Modify the main function to initialise the tracer in `main.go`. Initiate the tracer at the very beginning of our main function.
-    
-    ```go
-    func main() {
-        cleanup := initTracer()
-        defer cleanup(context.Background())
-    
-        ......
-    }
-    ```
-    
-5. **Add the OpenTelemetry Gin middleware**
-   
-   Configure Gin to use the middleware by adding the following lines in `main.go`.
-    
-    ```go
-    import (
-        ....
-      "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
-    )
-    
-    func main() {
-        ......
-        r := gin.Default()
-        r.Use(otelgin.Middleware(serviceName))
-        ......
-    }
-    ```
-    
-6. **Set environment variables and run your Go Gin application**
-
-   The run command must have some environment variables to send data to SigNoz. The run command:
-    
-    ```bash
-    SERVICE_NAME={{MYAPP}} INSECURE_MODE=true OTEL_EXPORTER_OTLP_ENDPOINT=localhost:4317 go run main.go
-    ```
-    
-    If you want to update your `service_name`, you can modify the `SERVICE_NAME` variable.

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/Docker/QuickStart/golang-docker-quickStart-instrumentApplication.md

@@ -1,135 +0,0 @@
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-go get go.opentelemetry.io/otel \
-  go.opentelemetry.io/otel/trace \
-  go.opentelemetry.io/otel/sdk \
-  go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
-```
-
-**Note:** We are assuming you are using gin request router. If you are using other request routers, check out the [corresponding package](https://signoz.io/docs/instrumentation/golang/#request-routers).
- 
- 
-
-### Step 2: Declare environment variables for configuring OpenTelemetry
-Declare the following global variables in **`main.go`** which we will use to configure OpenTelemetry:
-```bash
- var (
-     serviceName  = os.Getenv("SERVICE_NAME")
-     collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-     insecure     = os.Getenv("INSECURE_MODE")
- )
-```
- 
-
-### Step 3: Instrument your Go application 
-To configure your application to send data we will need a function to initialize OpenTelemetry. Add the following snippet of code in your **`main.go`** file.
-
-```bash
-     
- import (
-     .....
-
-     "google.golang.org/grpc/credentials"
-     "github.com/gin-gonic/gin"
-     "go.opentelemetry.io/otel"
-     "go.opentelemetry.io/otel/attribute"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-
-     "go.opentelemetry.io/otel/sdk/resource"
-     sdktrace "go.opentelemetry.io/otel/sdk/trace"
- )
-
- func initTracer() func(context.Context) error {
-
-     var secureOption otlptracegrpc.Option
-
-     if strings.ToLower(insecure) == "false" || insecure == "0" || strings.ToLower(insecure) == "f" {
-         secureOption = otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
-     } else {
-         secureOption = otlptracegrpc.WithInsecure()
-     }
-
-     exporter, err := otlptrace.New(
-         context.Background(),
-         otlptracegrpc.NewClient(
-             secureOption,
-             otlptracegrpc.WithEndpoint(collectorURL),
-         ),
-     )
-
-     if err != nil {
-         log.Fatalf("Failed to create exporter: %v", err)
-     }
-     resources, err := resource.New(
-         context.Background(),
-         resource.WithAttributes(
-             attribute.String("service.name", serviceName),
-             attribute.String("library.language", "go"),
-         ),
-     )
-     if err != nil {
-         log.Fatalf("Could not set resources: %v", err)
-     }
-
-     otel.SetTracerProvider(
-         sdktrace.NewTracerProvider(
-             sdktrace.WithSampler(sdktrace.AlwaysSample()),
-             sdktrace.WithBatcher(exporter),
-             sdktrace.WithResource(resources),
-         ),
-     )
-     return exporter.Shutdown
- }
-```
- 
-
-### Step 4: Initialise the tracer in **`main.go`**
-Modify the main function to initialise the tracer in **`main.go`**. Initiate the tracer at the very beginning of our main function.
-```bash
-func main() {
-    cleanup := initTracer()
-    defer cleanup(context.Background())
-
-    ......
-}
-```
- 
-
-### Step 5: Add the OpenTelemetry Gin middleware
-Configure Gin to use the middleware by adding the following lines in **`main.go`**
-```bash
-import (
-    ....
-  "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
-)
-
-func main() {
-    ......
-    r := gin.Default()
-    r.Use(otelgin.Middleware(serviceName))
-    ......
-}
-```
-
- 
-
-### Step 6: Dockerize your application
-
-Set the environment variables in your Dockerfile.
-
-```bash
-...
-# Set environment variables
-ENV SERVICE_NAME={{MYAPP}} \
-    INSECURE_MODE=false \
-    OTEL_EXPORTER_OTLP_HEADERS="signoz-ingestion-key=b{{SIGNOZ_INGESTION_KEY}}" \
-    OTEL_EXPORTER_OTLP_ENDPOINT=ingest.{{REGION}}.signoz.cloud:443
-...
-```
-

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/Docker/QuickStart/golang-docker-quickStart-runApplication.md

@@ -1,21 +0,0 @@
-Once you update your Dockerfile, you can build and run it using the commands below.
-
- 
-
-### Step 1: Build your dockerfile
-
-Build your docker image
-
-```bash
-docker build -t <your-image-name> .
-```
-
-- `<your-image-name>` is the name of your Docker Image
-
-&nbsp;
-
-### Step 2: Run your docker image
-
-```bash
-docker run <your-image-name>
-```

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/Docker/Recommended/golang-docker-recommended-installOtelCollector.md

@@ -1,12 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
-
- 
-
-As a first step, you should install the OTel collector Binary according to the instructions provided on [this link](https://signoz.io/docs/tutorial/opentelemetry-binary-usage-in-virtual-machine/).
-
- 
-
-Once you are done setting up the OTel collector binary, you can follow the next steps.
-
- 
-

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/Docker/Recommended/golang-docker-recommended-instrumentApplication.md

@@ -1,137 +0,0 @@
-After setting up the Otel collector agent, follow the steps below to instrument your Go Application
- 
- 
-
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-go get go.opentelemetry.io/otel \
-  go.opentelemetry.io/otel/trace \
-  go.opentelemetry.io/otel/sdk \
-  go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
-```
-
-**Note:** We are assuming you are using gin request router. If you are using other request routers, check out the [corresponding package](https://signoz.io/docs/instrumentation/golang/#request-routers).
- 
- 
-
-### Step 2: Declare environment variables for configuring OpenTelemetry
-Declare the following global variables in **`main.go`** which we will use to configure OpenTelemetry:
-```bash
- var (
-     serviceName  = os.Getenv("SERVICE_NAME")
-     collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-     insecure     = os.Getenv("INSECURE_MODE")
- )
-```
- 
-
-### Step 3: Instrument your Go application 
-To configure your application to send data we will need a function to initialize OpenTelemetry. Add the following snippet of code in your **`main.go`** file.
-
-```bash
-     
- import (
-     .....
-
-     "google.golang.org/grpc/credentials"
-     "github.com/gin-gonic/gin"
-     "go.opentelemetry.io/otel"
-     "go.opentelemetry.io/otel/attribute"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-
-     "go.opentelemetry.io/otel/sdk/resource"
-     sdktrace "go.opentelemetry.io/otel/sdk/trace"
- )
-
- func initTracer() func(context.Context) error {
-
-     var secureOption otlptracegrpc.Option
-
-     if strings.ToLower(insecure) == "false" || insecure == "0" || strings.ToLower(insecure) == "f" {
-         secureOption = otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
-     } else {
-         secureOption = otlptracegrpc.WithInsecure()
-     }
-
-     exporter, err := otlptrace.New(
-         context.Background(),
-         otlptracegrpc.NewClient(
-             secureOption,
-             otlptracegrpc.WithEndpoint(collectorURL),
-         ),
-     )
-
-     if err != nil {
-         log.Fatalf("Failed to create exporter: %v", err)
-     }
-     resources, err := resource.New(
-         context.Background(),
-         resource.WithAttributes(
-             attribute.String("service.name", serviceName),
-             attribute.String("library.language", "go"),
-         ),
-     )
-     if err != nil {
-         log.Fatalf("Could not set resources: %v", err)
-     }
-
-     otel.SetTracerProvider(
-         sdktrace.NewTracerProvider(
-             sdktrace.WithSampler(sdktrace.AlwaysSample()),
-             sdktrace.WithBatcher(exporter),
-             sdktrace.WithResource(resources),
-         ),
-     )
-     return exporter.Shutdown
- }
-```
- 
-
-### Step 4: Initialise the tracer in **`main.go`**
-Modify the main function to initialise the tracer in **`main.go`**. Initiate the tracer at the very beginning of our main function.
-```bash
-func main() {
-    cleanup := initTracer()
-    defer cleanup(context.Background())
-
-    ......
-}
-```
- 
-
-### Step 5: Add the OpenTelemetry Gin middleware
-Configure Gin to use the middleware by adding the following lines in **`main.go`**
-```bash
-import (
-    ....
-  "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
-)
-
-func main() {
-    ......
-    r := gin.Default()
-    r.Use(otelgin.Middleware(serviceName))
-    ......
-}
-```
-
- 
-
-### Step 6: Dockerize your application
-
-Set the environment variables in your Dockerfile.
-
-```bash
-...
-# Set environment variables
-ENV SERVICE_NAME={{MYAPP}} \
-    INSECURE_MODE=true \
-    OTEL_EXPORTER_OTLP_ENDPOINT=localhost:4317
-...
-```

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/Docker/Recommended/golang-docker-recommended-runApplication.md

@@ -1,21 +0,0 @@
-Once you update your Dockerfile, you can build and run it using the commands below.
-
- 
-
-### Step 1: Build your dockerfile
-
-Build your docker image
-
-```bash
-docker build -t <your-image-name> .
-```
-
-- `<your-image-name>` is the name of your Docker Image
-
-&nbsp;
-
-### Step 2: Run your docker image
-
-```bash
-docker run <your-image-name>
-```

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/Kubernetes/golang-kubernetes-installOtelCollector.md

@@ -1,43 +0,0 @@
-### Install otel-collector in your Kubernetes infra
-
-Add the SigNoz Helm Chart repository
-```bash
-helm repo add signoz https://charts.signoz.io
-```
-
- 
-
-If the chart is already present, update the chart to the latest using:
-```bash
-helm repo update
-```
-
- 
-
-For generic Kubernetes clusters, you can create *override-values.yaml* with the following configuration:
-
-```yaml
-global:
-  cloud: others
-  clusterName: <CLUSTER_NAME>
-  deploymentEnvironment: <DEPLOYMENT_ENVIRONMENT>
-otelCollectorEndpoint: ingest.{{REGION}}.signoz.cloud:443
-otelInsecure: false
-signozApiKey: {{SIGNOZ_INGESTION_KEY}}
-presets:
-  otlpExporter:
-    enabled: true
-  loggingExporter:
-    enabled: false
-```
-
-- Replace `<CLUSTER_NAME>` with the name of the Kubernetes cluster or a unique identifier of the cluster.
-- Replace `<DEPLOYMENT_ENVIRONMENT>` with the deployment environment of your application. Example: **"staging"**, **"production"**, etc.
-
-&nbsp;
-
-To install the k8s-infra chart with the above configuration, run the following command:
-
-```bash
-helm install my-release signoz/k8s-infra -f override-values.yaml
-```

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/Kubernetes/golang-kubernetes-instrumentApplication.md

@@ -1,124 +0,0 @@
-After setting up the Otel collector agent, follow the steps below to instrument your Go Application
- 
- 
-
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-go get go.opentelemetry.io/otel \
-  go.opentelemetry.io/otel/trace \
-  go.opentelemetry.io/otel/sdk \
-  go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
-```
-
-**Note:** We are assuming you are using gin request router. If you are using other request routers, check out the [corresponding package](https://signoz.io/docs/instrumentation/golang/#request-routers).
- 
- 
-
-### Step 2: Declare environment variables for configuring OpenTelemetry
-Declare the following global variables in **`main.go`** which we will use to configure OpenTelemetry:
-```bash
- var (
-     serviceName  = os.Getenv("SERVICE_NAME")
-     collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-     insecure     = os.Getenv("INSECURE_MODE")
- )
-```
- 
-
-### Step 3: Instrument your Go application 
-To configure your application to send data we will need a function to initialize OpenTelemetry. Add the following snippet of code in your **`main.go`** file.
-
-```bash
-     
- import (
-     .....
-     
-     "google.golang.org/grpc/credentials"
-     "github.com/gin-gonic/gin"
-     "go.opentelemetry.io/otel"
-     "go.opentelemetry.io/otel/attribute"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-
-     "go.opentelemetry.io/otel/sdk/resource"
-     sdktrace "go.opentelemetry.io/otel/sdk/trace"
- )
-
- func initTracer() func(context.Context) error {
-
-     var secureOption otlptracegrpc.Option
-
-     if strings.ToLower(insecure) == "false" || insecure == "0" || strings.ToLower(insecure) == "f" {
-         secureOption = otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
-     } else {
-         secureOption = otlptracegrpc.WithInsecure()
-     }
-
-     exporter, err := otlptrace.New(
-         context.Background(),
-         otlptracegrpc.NewClient(
-             secureOption,
-             otlptracegrpc.WithEndpoint(collectorURL),
-         ),
-     )
-
-     if err != nil {
-         log.Fatalf("Failed to create exporter: %v", err)
-     }
-     resources, err := resource.New(
-         context.Background(),
-         resource.WithAttributes(
-             attribute.String("service.name", serviceName),
-             attribute.String("library.language", "go"),
-         ),
-     )
-     if err != nil {
-         log.Fatalf("Could not set resources: %v", err)
-     }
-
-     otel.SetTracerProvider(
-         sdktrace.NewTracerProvider(
-             sdktrace.WithSampler(sdktrace.AlwaysSample()),
-             sdktrace.WithBatcher(exporter),
-             sdktrace.WithResource(resources),
-         ),
-     )
-     return exporter.Shutdown
- }
-```
- 
-
-### Step 4: Initialise the tracer in **`main.go`**
-Modify the main function to initialise the tracer in **`main.go`**. Initiate the tracer at the very beginning of our main function.
-```bash
-func main() {
-    cleanup := initTracer()
-    defer cleanup(context.Background())
-
-    ......
-}
-```
- 
-
-### Step 5: Add the OpenTelemetry Gin middleware
-Configure Gin to use the middleware by adding the following lines in **`main.go`**
-```bash
-import (
-    ....
-  "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
-)
-
-func main() {
-    ......
-    r := gin.Default()
-    r.Use(otelgin.Middleware(serviceName))
-    ......
-}
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/Kubernetes/golang-kubernetes-runApplication.md

@@ -1,7 +0,0 @@
- 
-
-To run your Go Gin application, use the below command :
-
-```bash
-SERVICE_NAME={{MYAPP}} INSECURE_MODE=true OTEL_EXPORTER_OTLP_ENDPOINT=localhost:4317 go run main.go
-```

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/LinuxAMD64/QuickStart/golang-linuxamd64-quickStart-instrumentApplication.md

@@ -1,120 +0,0 @@
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-go get go.opentelemetry.io/otel \
-  go.opentelemetry.io/otel/trace \
-  go.opentelemetry.io/otel/sdk \
-  go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
-```
-
-**Note:** We are assuming you are using gin request router. If you are using other request routers, check out the [corresponding package](https://signoz.io/docs/instrumentation/golang/#request-routers).
- 
- 
-
-### Step 2: Declare environment variables for configuring OpenTelemetry
-Declare the following global variables in **`main.go`** which we will use to configure OpenTelemetry:
-```bash
- var (
-     serviceName  = os.Getenv("SERVICE_NAME")
-     collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-     insecure     = os.Getenv("INSECURE_MODE")
- )
-```
- 
-
-### Step 3: Instrument your Go application 
-To configure your application to send data we will need a function to initialize OpenTelemetry. Add the following snippet of code in your **`main.go`** file.
-
-```bash
-     
- import (
-     .....
-
-     "google.golang.org/grpc/credentials"
-     "github.com/gin-gonic/gin"
-     "go.opentelemetry.io/otel"
-     "go.opentelemetry.io/otel/attribute"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-
-     "go.opentelemetry.io/otel/sdk/resource"
-     sdktrace "go.opentelemetry.io/otel/sdk/trace"
- )
-
- func initTracer() func(context.Context) error {
-
-     var secureOption otlptracegrpc.Option
-
-     if strings.ToLower(insecure) == "false" || insecure == "0" || strings.ToLower(insecure) == "f" {
-         secureOption = otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
-     } else {
-         secureOption = otlptracegrpc.WithInsecure()
-     }
-
-     exporter, err := otlptrace.New(
-         context.Background(),
-         otlptracegrpc.NewClient(
-             secureOption,
-             otlptracegrpc.WithEndpoint(collectorURL),
-         ),
-     )
-
-     if err != nil {
-         log.Fatalf("Failed to create exporter: %v", err)
-     }
-     resources, err := resource.New(
-         context.Background(),
-         resource.WithAttributes(
-             attribute.String("service.name", serviceName),
-             attribute.String("library.language", "go"),
-         ),
-     )
-     if err != nil {
-         log.Fatalf("Could not set resources: %v", err)
-     }
-
-     otel.SetTracerProvider(
-         sdktrace.NewTracerProvider(
-             sdktrace.WithSampler(sdktrace.AlwaysSample()),
-             sdktrace.WithBatcher(exporter),
-             sdktrace.WithResource(resources),
-         ),
-     )
-     return exporter.Shutdown
- }
-```
- 
-
-### Step 4: Initialise the tracer in **`main.go`**
-Modify the main function to initialise the tracer in **`main.go`**. Initiate the tracer at the very beginning of our main function.
-```bash
-func main() {
-    cleanup := initTracer()
-    defer cleanup(context.Background())
-
-    ......
-}
-```
- 
-
-### Step 5: Add the OpenTelemetry Gin middleware
-Configure Gin to use the middleware by adding the following lines in **`main.go`**
-```bash
-import (
-    ....
-  "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
-)
-
-func main() {
-    ......
-    r := gin.Default()
-    r.Use(otelgin.Middleware(serviceName))
-    ......
-}
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/LinuxAMD64/QuickStart/golang-linuxamd64-quickStart-runApplication.md

@@ -1,6 +0,0 @@
- 
-To run your Go Gin application, use the below command :
-
-```bash
-SERVICE_NAME={{MYAPP}} INSECURE_MODE=false OTEL_EXPORTER_OTLP_HEADERS=signoz-ingestion-key={{SIGNOZ_INGESTION_KEY}} OTEL_EXPORTER_OTLP_ENDPOINT=ingest.{{REGION}}.signoz.cloud:443 go run main.go
-```

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/LinuxAMD64/Recommended/golang-linuxamd64-recommended-installOtelCollector.md

@@ -1,96 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
- 
-
-### Step 1: Download otel-collector tar.gz
-```bash
-wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v{{OTEL_VERSION}}/otelcol-contrib_{{OTEL_VERSION}}_linux_amd64.tar.gz
-```
- 
-
-### Step 2: Extract otel-collector tar.gz to the `otelcol-contrib` folder
-```bash
-mkdir otelcol-contrib && tar xvzf otelcol-contrib_{{OTEL_VERSION}}_linux_amd64.tar.gz -C otelcol-contrib
-```
- 
-
-### Step 3: Create `config.yaml` in `otelcol-contrib` folder with the below content in it
-```bash
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: 0.0.0.0:4317
-      http:
-        endpoint: 0.0.0.0:4318
-  hostmetrics:
-    collection_interval: 60s
-    scrapers:
-      cpu: {}
-      disk: {}
-      load: {}
-      filesystem: {}
-      memory: {}
-      network: {}
-      paging: {}
-      process:
-        mute_process_name_error: true
-        mute_process_exe_error: true
-        mute_process_io_error: true
-      processes: {}
-  prometheus:
-    config:
-      global:
-        scrape_interval: 60s
-      scrape_configs:
-        - job_name: otel-collector-binary
-          static_configs:
-            - targets:
-              # - localhost:8888
-processors:
-  batch:
-    send_batch_size: 1000
-    timeout: 10s
-  # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
-  resourcedetection:
-    detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
-    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
-    timeout: 2s
-    system:
-      hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
-extensions:
-  health_check: {}
-  zpages: {}
-exporters:
-  otlp:
-    endpoint: "ingest.{{REGION}}.signoz.cloud:443"
-    tls:
-      insecure: false
-    headers:
-      "signoz-ingestion-key": "{{SIGNOZ_INGESTION_KEY}}"
-  logging:
-    verbosity: normal
-service:
-  telemetry:
-    metrics:
-      address: 0.0.0.0:8888
-  extensions: [health_check, zpages]
-  pipelines:
-    metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    metrics/internal:
-      receivers: [prometheus, hostmetrics]
-      processors: [resourcedetection, batch]
-      exporters: [otlp]
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    logs:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/LinuxAMD64/Recommended/golang-linuxamd64-recommended-instrumentApplication.md

@@ -1,124 +0,0 @@
-After setting up the Otel collector agent, follow the steps below to instrument your Go Application
- 
- 
-
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-go get go.opentelemetry.io/otel \
-  go.opentelemetry.io/otel/trace \
-  go.opentelemetry.io/otel/sdk \
-  go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
-```
-
-**Note:** We are assuming you are using gin request router. If you are using other request routers, check out the [corresponding package](https://signoz.io/docs/instrumentation/golang/#request-routers).
- 
- 
-
-### Step 2: Declare environment variables for configuring OpenTelemetry
-Declare the following global variables in **`main.go`** which we will use to configure OpenTelemetry:
-```bash
- var (
-     serviceName  = os.Getenv("SERVICE_NAME")
-     collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-     insecure     = os.Getenv("INSECURE_MODE")
- )
-```
- 
-
-### Step 3: Instrument your Go application 
-To configure your application to send data we will need a function to initialize OpenTelemetry. Add the following snippet of code in your **`main.go`** file.
-
-```bash
-     
- import (
-     .....
-
-     "google.golang.org/grpc/credentials"
-     "github.com/gin-gonic/gin"
-     "go.opentelemetry.io/otel"
-     "go.opentelemetry.io/otel/attribute"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-
-     "go.opentelemetry.io/otel/sdk/resource"
-     sdktrace "go.opentelemetry.io/otel/sdk/trace"
- )
-
- func initTracer() func(context.Context) error {
-
-     var secureOption otlptracegrpc.Option
-
-     if strings.ToLower(insecure) == "false" || insecure == "0" || strings.ToLower(insecure) == "f" {
-         secureOption = otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
-     } else {
-         secureOption = otlptracegrpc.WithInsecure()
-     }
-
-     exporter, err := otlptrace.New(
-         context.Background(),
-         otlptracegrpc.NewClient(
-             secureOption,
-             otlptracegrpc.WithEndpoint(collectorURL),
-         ),
-     )
-
-     if err != nil {
-         log.Fatalf("Failed to create exporter: %v", err)
-     }
-     resources, err := resource.New(
-         context.Background(),
-         resource.WithAttributes(
-             attribute.String("service.name", serviceName),
-             attribute.String("library.language", "go"),
-         ),
-     )
-     if err != nil {
-         log.Fatalf("Could not set resources: %v", err)
-     }
-
-     otel.SetTracerProvider(
-         sdktrace.NewTracerProvider(
-             sdktrace.WithSampler(sdktrace.AlwaysSample()),
-             sdktrace.WithBatcher(exporter),
-             sdktrace.WithResource(resources),
-         ),
-     )
-     return exporter.Shutdown
- }
-```
- 
-
-### Step 4: Initialise the tracer in **`main.go`**
-Modify the main function to initialise the tracer in **`main.go`**. Initiate the tracer at the very beginning of our main function.
-```bash
-func main() {
-    cleanup := initTracer()
-    defer cleanup(context.Background())
-
-    ......
-}
-```
- 
-
-### Step 5: Add the OpenTelemetry Gin middleware
-Configure Gin to use the middleware by adding the following lines in **`main.go`**
-```bash
-import (
-    ....
-  "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
-)
-
-func main() {
-    ......
-    r := gin.Default()
-    r.Use(otelgin.Middleware(serviceName))
-    ......
-}
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/LinuxAMD64/Recommended/golang-linuxamd64-recommended-runApplication.md

@@ -1,27 +0,0 @@
- 
-Once you are done intrumenting your Go Gin application, you can run it using the below commands
- 
-
-### Step 1: Run OTel Collector
- Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step
-
-```bash
-./otelcol-contrib --config ./config.yaml &> otelcol-output.log & echo "$!" > otel-pid
-```
- 
-
-#### (Optional Step): View last 50 lines of `otelcol` logs
-```bash
-tail -f -n 50 otelcol-output.log
-```
-
-#### (Optional Step): Stop `otelcol`
-```bash
-kill "$(< otel-pid)"
-```
-&nbsp;
-
-### Step 2: Set environment variables and run your Go Gin application
-```bash
-SERVICE_NAME={{MYAPP}} INSECURE_MODE=true OTEL_EXPORTER_OTLP_ENDPOINT=localhost:4317 go run main.go
-```

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/LinuxARM64/QuickStart/golang-linuxarm64-quickStart-instrumentApplication.md

@@ -1,120 +0,0 @@
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-go get go.opentelemetry.io/otel \
-  go.opentelemetry.io/otel/trace \
-  go.opentelemetry.io/otel/sdk \
-  go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
-```
-
-**Note:** We are assuming you are using gin request router. If you are using other request routers, check out the [corresponding package](https://signoz.io/docs/instrumentation/golang/#request-routers).
- 
- 
-
-### Step 2: Declare environment variables for configuring OpenTelemetry
-Declare the following global variables in **`main.go`** which we will use to configure OpenTelemetry:
-```bash
- var (
-     serviceName  = os.Getenv("SERVICE_NAME")
-     collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-     insecure     = os.Getenv("INSECURE_MODE")
- )
-```
- 
-
-### Step 3: Instrument your Go application 
-To configure your application to send data we will need a function to initialize OpenTelemetry. Add the following snippet of code in your **`main.go`** file.
-
-```bash
-     
- import (
-     .....
-
-     "google.golang.org/grpc/credentials"
-     "github.com/gin-gonic/gin"
-     "go.opentelemetry.io/otel"
-     "go.opentelemetry.io/otel/attribute"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-
-     "go.opentelemetry.io/otel/sdk/resource"
-     sdktrace "go.opentelemetry.io/otel/sdk/trace"
- )
-
- func initTracer() func(context.Context) error {
-
-     var secureOption otlptracegrpc.Option
-
-     if strings.ToLower(insecure) == "false" || insecure == "0" || strings.ToLower(insecure) == "f" {
-         secureOption = otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
-     } else {
-         secureOption = otlptracegrpc.WithInsecure()
-     }
-
-     exporter, err := otlptrace.New(
-         context.Background(),
-         otlptracegrpc.NewClient(
-             secureOption,
-             otlptracegrpc.WithEndpoint(collectorURL),
-         ),
-     )
-
-     if err != nil {
-         log.Fatalf("Failed to create exporter: %v", err)
-     }
-     resources, err := resource.New(
-         context.Background(),
-         resource.WithAttributes(
-             attribute.String("service.name", serviceName),
-             attribute.String("library.language", "go"),
-         ),
-     )
-     if err != nil {
-         log.Fatalf("Could not set resources: %v", err)
-     }
-
-     otel.SetTracerProvider(
-         sdktrace.NewTracerProvider(
-             sdktrace.WithSampler(sdktrace.AlwaysSample()),
-             sdktrace.WithBatcher(exporter),
-             sdktrace.WithResource(resources),
-         ),
-     )
-     return exporter.Shutdown
- }
-```
- 
-
-### Step 4: Initialise the tracer in **`main.go`**
-Modify the main function to initialise the tracer in **`main.go`**. Initiate the tracer at the very beginning of our main function.
-```bash
-func main() {
-    cleanup := initTracer()
-    defer cleanup(context.Background())
-
-    ......
-}
-```
- 
-
-### Step 5: Add the OpenTelemetry Gin middleware
-Configure Gin to use the middleware by adding the following lines in **`main.go`**
-```bash
-import (
-    ....
-  "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
-)
-
-func main() {
-    ......
-    r := gin.Default()
-    r.Use(otelgin.Middleware(serviceName))
-    ......
-}
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/LinuxARM64/QuickStart/golang-linuxarm64-quickStart-runApplication.md

@@ -1,6 +0,0 @@
- 
-To run your Go Gin application, use the below command :
-
-```bash
-SERVICE_NAME={{MYAPP}} INSECURE_MODE=false OTEL_EXPORTER_OTLP_HEADERS=signoz-ingestion-key={{SIGNOZ_INGESTION_KEY}} OTEL_EXPORTER_OTLP_ENDPOINT=ingest.{{REGION}}.signoz.cloud:443 go run main.go
-```

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/LinuxARM64/Recommended/golang-linuxarm64-recommended-installOtelCollector.md

@@ -1,99 +0,0 @@
-## Setup OpenTelemetry Binary as an agent
-
- 
- 
-
-### Step 1: Download otel-collector tar.gz
-```bash
-wget https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v{{OTEL_VERSION}}/otelcol-contrib_{{OTEL_VERSION}}_linux_arm64.tar.gz
-```
- 
-
-### Step 2: Extract otel-collector tar.gz to the `otelcol-contrib` folder
-```bash
-mkdir otelcol-contrib && tar xvzf otelcol-contrib_{{OTEL_VERSION}}_linux_arm64.tar.gz -C otelcol-contrib
-```
- 
- 
-
-### Step 3: Create `config.yaml` in `otelcol-contrib` folder with the below content in it
-```bash
-receivers:
-  otlp:
-    protocols:
-      grpc:
-        endpoint: 0.0.0.0:4317
-      http:
-        endpoint: 0.0.0.0:4318
-  hostmetrics:
-    collection_interval: 60s
-    scrapers:
-      cpu: {}
-      disk: {}
-      load: {}
-      filesystem: {}
-      memory: {}
-      network: {}
-      paging: {}
-      process:
-        mute_process_name_error: true
-        mute_process_exe_error: true
-        mute_process_io_error: true
-      processes: {}
-  prometheus:
-    config:
-      global:
-        scrape_interval: 60s
-      scrape_configs:
-        - job_name: otel-collector-binary
-          static_configs:
-            - targets:
-              # - localhost:8888
-processors:
-  batch:
-    send_batch_size: 1000
-    timeout: 10s
-  # Ref: https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/processor/resourcedetectionprocessor/README.md
-  resourcedetection:
-    detectors: [env, system] # Before system detector, include ec2 for AWS, gcp for GCP and azure for Azure.
-    # Using OTEL_RESOURCE_ATTRIBUTES envvar, env detector adds custom labels.
-    timeout: 2s
-    system:
-      hostname_sources: [os] # alternatively, use [dns,os] for setting FQDN as host.name and os as fallback
-extensions:
-  health_check: {}
-  zpages: {}
-exporters:
-  otlp:
-    endpoint: "ingest.{{REGION}}.signoz.cloud:443"
-    tls:
-      insecure: false
-    headers:
-      "signoz-ingestion-key": "{{SIGNOZ_INGESTION_KEY}}"
-  logging:
-    verbosity: normal
-service:
-  telemetry:
-    metrics:
-      address: 0.0.0.0:8888
-  extensions: [health_check, zpages]
-  pipelines:
-    metrics:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    metrics/internal:
-      receivers: [prometheus, hostmetrics]
-      processors: [resourcedetection, batch]
-      exporters: [otlp]
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-    logs:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/LinuxARM64/Recommended/golang-linuxarm64-recommended-instrumentApplication.md

@@ -1,124 +0,0 @@
-After setting up the Otel collector agent, follow the steps below to instrument your Go Application
- 
- 
-
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-go get go.opentelemetry.io/otel \
-  go.opentelemetry.io/otel/trace \
-  go.opentelemetry.io/otel/sdk \
-  go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
-```
-
-**Note:** We are assuming you are using gin request router. If you are using other request routers, check out the [corresponding package](https://signoz.io/docs/instrumentation/golang/#request-routers).
- 
- 
-
-### Step 2: Declare environment variables for configuring OpenTelemetry
-Declare the following global variables in **`main.go`** which we will use to configure OpenTelemetry:
-```bash
- var (
-     serviceName  = os.Getenv("SERVICE_NAME")
-     collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-     insecure     = os.Getenv("INSECURE_MODE")
- )
-```
- 
-
-### Step 3: Instrument your Go application 
-To configure your application to send data we will need a function to initialize OpenTelemetry. Add the following snippet of code in your **`main.go`** file.
-
-```bash
-     
- import (
-     .....
-
-     "google.golang.org/grpc/credentials"
-     "github.com/gin-gonic/gin"
-     "go.opentelemetry.io/otel"
-     "go.opentelemetry.io/otel/attribute"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-
-     "go.opentelemetry.io/otel/sdk/resource"
-     sdktrace "go.opentelemetry.io/otel/sdk/trace"
- )
-
- func initTracer() func(context.Context) error {
-
-     var secureOption otlptracegrpc.Option
-
-     if strings.ToLower(insecure) == "false" || insecure == "0" || strings.ToLower(insecure) == "f" {
-         secureOption = otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
-     } else {
-         secureOption = otlptracegrpc.WithInsecure()
-     }
-
-     exporter, err := otlptrace.New(
-         context.Background(),
-         otlptracegrpc.NewClient(
-             secureOption,
-             otlptracegrpc.WithEndpoint(collectorURL),
-         ),
-     )
-
-     if err != nil {
-         log.Fatalf("Failed to create exporter: %v", err)
-     }
-     resources, err := resource.New(
-         context.Background(),
-         resource.WithAttributes(
-             attribute.String("service.name", serviceName),
-             attribute.String("library.language", "go"),
-         ),
-     )
-     if err != nil {
-         log.Fatalf("Could not set resources: %v", err)
-     }
-
-     otel.SetTracerProvider(
-         sdktrace.NewTracerProvider(
-             sdktrace.WithSampler(sdktrace.AlwaysSample()),
-             sdktrace.WithBatcher(exporter),
-             sdktrace.WithResource(resources),
-         ),
-     )
-     return exporter.Shutdown
- }
-```
- 
-
-### Step 4: Initialise the tracer in **`main.go`**
-Modify the main function to initialise the tracer in **`main.go`**. Initiate the tracer at the very beginning of our main function.
-```bash
-func main() {
-    cleanup := initTracer()
-    defer cleanup(context.Background())
-
-    ......
-}
-```
- 
-
-### Step 5: Add the OpenTelemetry Gin middleware
-Configure Gin to use the middleware by adding the following lines in **`main.go`**
-```bash
-import (
-    ....
-  "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
-)
-
-func main() {
-    ......
-    r := gin.Default()
-    r.Use(otelgin.Middleware(serviceName))
-    ......
-}
-```
-
-

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/LinuxARM64/Recommended/golang-linuxarm64-recommended-runApplication.md

@@ -1,27 +0,0 @@
- 
-Once you are done intrumenting your Go Gin application, you can run it using the below commands
- 
-
-### Step 1: Run OTel Collector
- Run this command inside the `otelcol-contrib` directory that you created in the install Otel Collector step
-
-```bash
-./otelcol-contrib --config ./config.yaml &> otelcol-output.log & echo "$!" > otel-pid
-```
- 
-
-#### (Optional Step): View last 50 lines of `otelcol` logs
-```bash
-tail -f -n 50 otelcol-output.log
-```
-
-#### (Optional Step): Stop `otelcol`
-```bash
-kill "$(< otel-pid)"
-```
-&nbsp;
-
-### Step 2: Set environment variables and run your Go Gin application
-```bash
-SERVICE_NAME={{MYAPP}} INSECURE_MODE=true OTEL_EXPORTER_OTLP_ENDPOINT=localhost:4317 go run main.go
-```

frontend/src/container/OnboardingContainer/Modules/APM/GoLang/md-docs/MacOsAMD64/QuickStart/golang-macosamd64-quickStart-instrumentApplication.md

@@ -1,120 +0,0 @@
-### Step 1: Install OpenTelemetry Dependencies
-Dependencies related to OpenTelemetry exporter and SDK have to be installed first.
-
-Run the below commands after navigating to the application source folder:
-```bash
-go get go.opentelemetry.io/otel \
-  go.opentelemetry.io/otel/trace \
-  go.opentelemetry.io/otel/sdk \
-  go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace \
-  go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
-```
-
-**Note:** We are assuming you are using gin request router. If you are using other request routers, check out the [corresponding package](https://signoz.io/docs/instrumentation/golang/#request-routers).
- 
- 
-
-### Step 2: Declare environment variables for configuring OpenTelemetry
-Declare the following global variables in **`main.go`** which we will use to configure OpenTelemetry:
-```bash
- var (
-     serviceName  = os.Getenv("SERVICE_NAME")
-     collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-     insecure     = os.Getenv("INSECURE_MODE")
- )
-```
- 
-
-### Step 3: Instrument your Go application 
-To configure your application to send data we will need a function to initialize OpenTelemetry. Add the following snippet of code in your **`main.go`** file.
-
-```bash
-     
- import (
-     .....
-
-     "google.golang.org/grpc/credentials"
-     "github.com/gin-gonic/gin"
-     "go.opentelemetry.io/otel"
-     "go.opentelemetry.io/otel/attribute"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
-     "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
-
-     "go.opentelemetry.io/otel/sdk/resource"
-     sdktrace "go.opentelemetry.io/otel/sdk/trace"
- )
-
- func initTracer() func(context.Context) error {
-
-     var secureOption otlptracegrpc.Option
-
-     if strings.ToLower(insecure) == "false" || insecure == "0" || strings.ToLower(insecure) == "f" {
-         secureOption = otlptracegrpc.WithTLSCredentials(credentials.NewClientTLSFromCert(nil, ""))
-     } else {
-         secureOption = otlptracegrpc.WithInsecure()
-     }
-
-     exporter, err := otlptrace.New(
-         context.Background(),
-         otlptracegrpc.NewClient(
-             secureOption,
-             otlptracegrpc.WithEndpoint(collectorURL),
-         ),
-     )
-
-     if err != nil {
-         log.Fatalf("Failed to create exporter: %v", err)
-     }
-     resources, err := resource.New(
-         context.Background(),
-         resource.WithAttributes(
-             attribute.String("service.name", serviceName),
-             attribute.String("library.language", "go"),
-         ),
-     )
-     if err != nil {
-         log.Fatalf("Could not set resources: %v", err)
-     }
-
-     otel.SetTracerProvider(
-         sdktrace.NewTracerProvider(
-             sdktrace.WithSampler(sdktrace.AlwaysSample()),
-             sdktrace.WithBatcher(exporter),
-             sdktrace.WithResource(resources),
-         ),
-     )
-     return exporter.Shutdown
- }
-```
- 
-
-### Step 4: Initialise the tracer in **`main.go`**
-Modify the main function to initialise the tracer in **`main.go`**. Initiate the tracer at the very beginning of our main function.
-```bash
-func main() {
-    cleanup := initTracer()
-    defer cleanup(context.Background())
-
-    ......
-}
-```
- 
-
-### Step 5: Add the OpenTelemetry Gin middleware
-Configure Gin to use the middleware by adding the following lines in **`main.go`**
-```bash
-import (
-    ....
-  "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
-)
-
-func main() {
-    ......
-    r := gin.Default()
-    r.Use(otelgin.Middleware(serviceName))
-    ......
-}
-```
-
-