This guide walks you through configuring your existing OpenTelemetry instrumentation to send data to SigNoz Cloud. The process involves updating your export configuration - no changes to your application code are required.

Prerequisites

Before starting, ensure you have:

• Applications already instrumented with OpenTelemetry SDKs or OpenTelemetry collector
• An active SigNoz account
• Access to modify your application configuration or environment variables
• A valid ingestion key from your SigNoz Cloud account

Configuration for SigNoz Cloud

Step 1: Obtain Your Ingestion Key

First, you need to get your ingestion key from SigNoz Cloud:

1. Log into your SigNoz Cloud account
2. Navigate to Settings → Ingestion Settings
3. Copy your Ingestion Key - you'll need this for authentication

Step 2: Get Your Region Endpoint

Next, you need to identify the correct ingestion endpoint for your SigNoz Cloud region.

Your endpoint URL depends on your selected region:

Note: SigNoz uses port 443 for both HTTP and gRPC protocols.

Don't know your region? Navigate to Settings → Ingestion Settings in your SigNoz Cloud account to check your region and endpoint.

Step 3: Update OpenTelemetry Configuration

Now that you have your endpoint and ingestion key, you need to reconfigure your OpenTelemetry exporters to send data to SigNoz Cloud. You can do this either through environment variables (recommended) or by updating your application code directly.

Environment Variables (Recommended)

Set these environment variables for your application:

# Replace with your region's endpoint
export OTEL_EXPORTER_OTLP_ENDPOINT="https://ingest.us.signoz.cloud:443"

# Replace with your actual ingestion key
export OTEL_EXPORTER_OTLP_HEADERS="signoz-ingestion-key=YOUR_INGESTION_KEY"

# Enable compression for better performance
export OTEL_EXPORTER_OTLP_COMPRESSION="gzip"

# Optional: Increase timeout for large payloads
export OTEL_EXPORTER_OTLP_TIMEOUT="30000"

Programmatic Configuration Examples

If you prefer to configure exporters directly in code, here are examples for common languages:

Node.js

const { OTLPTraceExporter } = require('@opentelemetry/exporter-otlp-grpc');

const exporter = new OTLPTraceExporter({
  url: 'https://ingest.us.signoz.cloud:443',
  headers: { 'signoz-ingestion-key': 'YOUR_INGESTION_KEY' },
  compression: 'gzip'
});

Python

from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter

exporter = OTLPSpanExporter(
    endpoint="https://ingest.us.signoz.cloud:443",
    headers={"signoz-ingestion-key": "YOUR_INGESTION_KEY"},
    compression="gzip"
)

Go

exporter, err := otlptracegrpc.New(ctx,
    otlptracegrpc.WithEndpoint("https://ingest.us.signoz.cloud:443"),
    otlptracegrpc.WithHeaders(map[string]string{
        "signoz-ingestion-key": "YOUR_INGESTION_KEY",
    }),
)

Java

OtlpGrpcSpanExporter exporter = OtlpGrpcSpanExporter.builder()
    .setEndpoint("https://ingest.us.signoz.cloud:443")
    .addHeader("signoz-ingestion-key", "YOUR_INGESTION_KEY")
    .setCompression("gzip")
    .build();

.NET

using var tracerProvider = TracerProviderBuilder.Create()
    .AddOtlpExporter(options =>
    {
        options.Endpoint = new Uri("https://ingest.us.signoz.cloud:443");
        options.Headers = "signoz-ingestion-key=YOUR_INGESTION_KEY";
        options.Protocol = OtlpExportProtocol.Grpc;
    })
    .Build();

PHP

use OpenTelemetry\Contrib\Otlp\SpanExporter;

$exporter = new SpanExporter(
    'https://ingest.us.signoz.cloud:443',
    ['signoz-ingestion-key' => 'YOUR_INGESTION_KEY']
);

Ruby

require 'opentelemetry/exporter/otlp'

exporter = OpenTelemetry::Exporter::OTLP::Exporter.new(
  endpoint: 'https://ingest.us.signoz.cloud:443',
  headers: { 'signoz-ingestion-key' => 'YOUR_INGESTION_KEY' }
)

You can find more detailed examples covering more languages in the SigNoz instrumentation documentation.

Step 4: Update OpenTelemetry Collector Configuration

If you're using an OpenTelemetry Collector in your infrastructure to aggregate telemetry data before sending it to backends, you'll need to update its configuration to point to SigNoz Cloud.

What needs to be changed:

1. Replace the current exporter endpoint - Change from your existing backend (e.g., Jaeger, Prometheus) to SigNoz Cloud's OTLP endpoint
2. Add authentication headers - SigNoz Cloud requires an ingestion key for secure data transmission
3. Update TLS configuration - Ensure secure HTTPS communication with SigNoz Cloud
4. Verify pipeline configuration - Make sure all telemetry types (traces, metrics, logs) route to the updated exporter

Step-by-step changes:

Before: Your existing exporter configuration might look like:

exporters:
  # Sending traces to Jaeger
  otlp:
    endpoint: jaeger:4317
    tls:
      insecure: true
  # or sending metrics to Prometheus
  prometheus:
    endpoint: "0.0.0.0:9090"

After: Update to SigNoz Cloud exporter:

exporters:
  otlp:
    endpoint: "ingest.{region}.signoz.cloud:443"
    headers:
      signoz-ingestion-key: "<YOUR-INGESTION-KEY>"
    tls:
      insecure: false

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp]
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp]
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp]

After updating the configuration, restart your OpenTelemetry Collector to apply the changes.

Step 5: Test and Validate

Now it's time to verify that your OpenTelemetry data is successfully flowing to SigNoz Cloud.

1. Restart your application with the new configuration
2. Generate test data by using your application
3. Access SigNoz Dashboard - log into your SigNoz Cloud account
4. Verify data flow:
   • Navigate to Services tab - your applications should appear
   • Check Traces for individual requests
   • Verify Metrics and Logs if configured

Data should appear within 1-2 minutes. If not, check your application logs for export errors.

Next Steps

Now that your OpenTelemetry data is flowing to SigNoz Cloud:

• Set up alerts: Configure alerting rules for key metrics
• Create dashboards: Build custom dashboards for your team
• Explore APM features: Use distributed tracing to troubleshoot issues
• Monitor infrastructure: Set up infrastructure monitoring