Opentelemetry Instrumentation

OpenTelemetry SDK Instrumentation for Coralogix

When to Use This Skill

Load order: language-selector.md → language ref → coralogix-endpoints.md → output-templates.md (always last). Load troubleshooting.md only for debugging.

Answer Rules

Before answering (agent mode):

• Always call `list_references()` first, then `read_reference(...)` for the relevant files (language selector + the target language + endpoints; add troubleshooting only when debugging). Do not answer from memory if the references could affect correctness.
• Use the structure/checklists in [output-templates.md](references/output-templates.md) for any user-facing response; keep your own prose minimal and actionable.

Always include in generated answers:

• Required env vars (names only) — include these in any “copy/paste” setup:

OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_HEADERS, OTEL_SERVICE_NAME, OTEL_RESOURCE_ATTRIBUTES (plus OTEL_*_EXPORTER / OTEL_EXPORTER_OTLP_*_PROTOCOL when choosing signals/protocol). For exact per-language endpoint formats and the Python %20 env-var rule, use coralogix-endpoints.md.

• Required resource attributes — service.name (APM catalog/transactions), cx.application.name + cx.subsystem.name (routing, TCO, APM grouping), telemetry.sdk.language (auto-set; do not strip). Missing any silently degrades APM. Additional k8s/host attributes are covered in each language reference.

• Telemetry quality. Low-cardinality span names, no sensitive data, bounded metric attributes, structured single-line logs with trace/span IDs, validation steps for the signal. Never approve user-scoped values (user_id, tenant_id, request_id, session_id) as metric labels — they cause unbounded cardinality and will explode metric storage.
• Direct vs collector routing rule: Default to direct OTLP for dev/test environments, simple single-service production deployments, or when no collector infrastructure exists. Default to via-collector for Kubernetes workloads needing pod/namespace enrichment (k8sattributes), tail sampling, multi-service shared key management, or buffered retry/file persistence requirements. When the deployment context is unknown, show both options using the tradeoff table in language-selector.md.
• Collector config is out of scope. Redirect to opentelemetry-collector — do not partially answer pipeline or processor questions.

High-Risk Gotchas (Do Not Guess)

Keep this list short and only use it when the user’s symptom matches. For details, defer to the language references.

• Java agent: opentelemetry-javaagent.jar + JAVA_TOOL_OPTIONS="-javaagent:/path/to/opentelemetry-javaagent.jar".
• Java/.NET gRPC endpoint: must be a full URI https://ingress.<region>.coralogix.com:443 (URI parsing breaks bare host:port).
• Python auth header: env var needs %20 (Authorization=Bearer%20<KEY>); programmatic headers use a tuple sequence with lowercase key + literal space (("authorization", f"Bearer {token}")).
• Node.js HTTP/proto: exporter url must include /v1/traces (https://ingress.<region>.coralogix.com:443/v1/traces); gRPC doesn’t.
• Go gRPC: credentials.NewTLS(nil) and bare endpoint ingress.<region>.coralogix.com:443 (no https:// in WithEndpoint).
• Go metrics cardinality: sdk/metric defaults to a cardinality limit of 2000; use WithCardinalityLimit(0) only when you intentionally need unlimited series, and expect otel.metric.overflow=true when the limit is hit.
• .NET OTLP disk retry: OTEL_DOTNET_EXPERIMENTAL_OTLP_RETRY=disk now requires OTEL_DOTNET_EXPERIMENTAL_OTLP_DISK_RETRY_DIRECTORY_PATH; do not rely on an implicit temp-directory fallback.
• Transactions: require CoralogixTransactionSampler (Node.js: @coralogix/opentelemetry); bundled NODE_OPTIONS auto-instr doesn’t support Transactions.
• Short-lived Python scripts: SimpleSpanProcessor vs BatchSpanProcessor; metrics need PeriodicExportingMetricReader flush/wait.
• .NET Framework incoming propagation: OpenTelemetry.Instrumentation.AspNet + AddAspNetInstrumentation().

Workflow

• New setup: language-selector.md → language ref + coralogix-endpoints.md → generate with output-templates.md.
• Code review: language ref → review checklist in output-templates.md.
• Debugging: troubleshooting.md first; escalate to language ref only if SDK-side cause confirmed.

Limitations

• OTel Collector / OTTL — use opentelemetry-collector or opentelemetry-ottl.
• Lambda / serverless — use Coralogix Lambda layer docs; Payload Too Large OTLP errors are Lambda-layer concerns, not SDK.
• PHP, eBPF auto-instrumentation — not covered.
• Coralogix platform internals (data routing, index policies, APM UI config) — platform topics.

Deprecated native SDKs

Native Coralogix SDKs are EOL June 30, 2026 — redirect to OTel and do not provide configuration for legacy packages.

Upstream references

Coralogix OTel instrumentation: Java · Python · Node.js · .NET · Go

Coralogix OTel docs · OpenTelemetry official docs

direct-vs-collector-tradeoffs

You are a Coralogix support expert. A user has asked the following question:

---

Should I use the OpenTelemetry Collector or send directly from my app SDK to Coralogix?

---

dotnet-auto-endpoint-missing-https-scheme

You are a Coralogix support expert. A user has asked the following question:

---

My .NET auto-instrumented service has these env vars set but no traces appear: OTEL_EXPORTER_OTLP_ENDPOINT=ingress.eu1.coralogix.com:443 OTEL_EXPORTER_OTLP_HEADERS=Authorization=Bearer myKey What am I missing?

---

dotnet-coralogixcoresdk-deprecation-redirect

You are a Coralogix support expert. A user has asked the following question:

---

We have a .NET Core service using CoralogixCoreSDK. We want to add trace correlation to our logs. How do we do that with CoralogixCoreSDK?

---

dotnet-manual-sdk-https-scheme-eu1

You are a Coralogix support expert. A user has asked the following question:

---

I've set up .NET OpenTelemetry manual instrumentation for my eu1 service. My OTLP exporter reports 200 OK responses, so data is arriving at Coralogix. But nothing appears in the APM views — no service in the Service Catalog, no traces in Explore. My endpoint is https://ingress.eu1.coralogix.com:443. What resource attributes could cause data to arrive successfully but not appear in APM?

---

go-legacy-sdk-deprecation-redirect

You are a Coralogix support expert. A user has asked the following question:

---

We're currently using go-coralogix-sdk to send logs from our Go service to Coralogix. Is this still supported and should we keep using it?

---

go-manual-tls-sampler-ap2-setup

You are a Coralogix support expert. A user has asked the following question:

---

How do I instrument a Go application to send metrics and traces to Coralogix ap2 region?

---

go-required-env-vars-direct-eu2

You are a Coralogix support expert. A user has asked the following question:

---

Give me the required direct-export environment variables for sending OpenTelemetry traces from a Go service to Coralogix in eu2.

---

java-agent-spring-boot-setup

You are a Coralogix support expert. A user has asked the following question:

---

I want to instrument my Java Spring Boot application to send traces to Coralogix. We're on the eu2 region. How do I set it up?

---

java-k8s-operator-injection

You are a Coralogix support expert. A user has asked the following question:

---

I'm running a Java service in Kubernetes and want to use the OpenTelemetry Operator to auto-instrument it without changing the application code. How do I configure it?

---

java-withspan-custom-span-annotation

You are a Coralogix support expert. A user has asked the following question:

---

My Java app sends traces fine but I want to add a custom span to a specific method. How do I do it without changing the exporter setup?

---

nodejs-bundled-auto-no-transactions

You are a Coralogix support expert. A user has asked the following question:

---

I'm using Node.js with the bundled auto-instrumentation approach (@opentelemetry/auto-instrumentations-node via NODE_OPTIONS). My traces are appearing in Coralogix, but I don't see any data in the Transactions view in APM. Why?

---

nodejs-coralogix-logger-deprecation-redirect

You are a Coralogix support expert. A user has asked the following question:

---

I'm using the coralogix-logger npm package to send logs from my Node.js app. How do I configure it to send to a different Coralogix region?

---

nodejs-http-proto-missing-v1traces-path

You are a Coralogix support expert. A user has asked the following question:

---

My Node.js app uses OTLPTraceExporter (HTTP/proto) with url set to 'https://ingress.eu2.coralogix.com:443'. Traces are not arriving in Coralogix and the exporter returns no errors. What is the correct endpoint URL to use, and why does the current one fail silently?

---

nodejs-traceparent-not-propagated-to-dotnet-framework

You are a Coralogix support expert. A user has asked the following question:

---

My Node.js service injects a traceparent header into outgoing HTTP requests, but when the request reaches our .NET Framework backend I see independent spans in Coralogix instead of child spans — the trace is broken at the service boundary. What's wrong?

---

out-of-scope-collector-config-deflection

You are a Coralogix support expert. A user has asked the following question:

---

How do I configure the OpenTelemetry Collector to batch spans before sending to Coralogix?

---

python-bearer-space-url-encoded-env-var

You are a Coralogix support expert. A user has asked the following question:

---

I set up Python auto-instrumentation with opentelemetry-instrument for my Flask app and I'm sending to Coralogix (us1 region). My env vars are: OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer mySecretKey123" OTEL_EXPORTER_OTLP_ENDPOINT="https://ingress.us1.coralogix.com:443" OTEL_TRACES_EXPORTER=otlp_proto_grpc Nothing shows up in Coralogix. What's wrong?

---

python-logs-loggerprovider-setlevel

You are a Coralogix support expert. A user has asked the following question:

---

How do I send Python application logs to Coralogix using OpenTelemetry? We're on the eu2 region.

---

python-programmatic-headers-dict-case

You are a Coralogix support expert. A user has asked the following question:

---

I'm reviewing my Python programmatic instrumentation. Here's my exporter setup: headers = { 'Authorization': 'Bearer myKey', 'CX-Application-Name': 'myapp', } exporter = OTLPSpanExporter(endpoint='ingress.eu1.coralogix.com:443', headers=headers) What's wrong with this?

---

python-short-lived-script-flush-timing

You are a Coralogix support expert. A user has asked the following question:

---

I wrote a Python script that records some spans and a counter metric, then exits. The script finishes in about half a second. Nothing shows up in Coralogix — no traces, no metrics. What should I check?

---

python-tuple-headers-bearer-percent20-bug

You are a Coralogix support expert. A user has asked the following question:

---

My Python app is sending traces to Coralogix using OTLPSpanExporter with these programmatic headers: headers = ( ("authorization", "Bearer%20myApiKey123"), ) I'm getting StatusCode.UNAUTHENTICATED from the exporter. What's wrong?

---

telemetry-quality-cardinality-sensitive

You are a Coralogix support expert. A user has asked the following question:

---

I'm adding custom metrics and logs to my Coralogix-monitored service. I want to add user.id and tenant.id as attributes on every metric and span. I also want to log full request and response bodies as structured fields. Are there any risks specific to how Coralogix handles this data?

---

Coralogix Endpoints for SDK Instrumentation

Contents

• OTLP Endpoint for Direct SDK Export
• Regional Domains
• Authentication Header
• Coralogix-Specific OTLP Headers
• Endpoint vs Domain — SDK vs Collector
• PrivateLink

OTLP Endpoint for Direct SDK Export

When exporting directly from the SDK (not via a collector), the required endpoint format depends on the language:

Java and .NET — the SDK's URI parser requires a full URI with https:// scheme:

https://ingress.<region>.coralogix.com:443

Python and Node.js — the standard Coralogix gRPC form is bare host:port:

ingress.<region>.coralogix.com:443

The OpenTelemetry gRPC exporter spec also requires SDKs to accept https://host:port. So https://ingress.<region>.coralogix.com:443 is valid for Python and Node.js gRPC, but prefer the bare form in generated Coralogix examples.

Go — WithEndpoint uses bare host:port with no scheme or path:

ingress.<region>.coralogix.com:443

Use credentials.NewTLS(nil) with Go gRPC exporters. Do not pass https:// to WithEndpoint; use WithEndpointURL only when intentionally using a full URL option.

TLS is always enabled on port 443. Do not use http:// for direct Coralogix export — all Coralogix OTLP endpoints require TLS.

For HTTP/protobuf exporters (e.g. Node.js @opentelemetry/exporter-trace-otlp-proto), append the signal path:

https://ingress.<region>.coralogix.com:443/v1/traces
https://ingress.<region>.coralogix.com:443/v1/metrics
https://ingress.<region>.coralogix.com:443/v1/logs

Every generated direct-export setup must show these required environment variables. Choose the block that matches the language and protocol:

gRPC — Java and .NET (full URI with https:// scheme required):

export OTEL_EXPORTER_OTLP_ENDPOINT="https://ingress.<CORALOGIX_REGION>.coralogix.com:443"
export OTEL_EXPORTER_OTLP_PROTOCOL="grpc"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
export OTEL_SERVICE_NAME="<SERVICE_NAME>"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=<CX_APPLICATION_NAME>,cx.subsystem.name=<CX_SUBSYSTEM_NAME>"

gRPC — Python, Node.js, and Go (bare host:port; no https:// for Go WithEndpoint):

export OTEL_EXPORTER_OTLP_ENDPOINT="ingress.<CORALOGIX_REGION>.coralogix.com:443"
export OTEL_EXPORTER_OTLP_PROTOCOL="grpc"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
export OTEL_SERVICE_NAME="<SERVICE_NAME>"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=<CX_APPLICATION_NAME>,cx.subsystem.name=<CX_SUBSYSTEM_NAME>"

Python env var exception: Authorization=Bearer%20<CORALOGIX_API_KEY> (URL-encoded space).

HTTP/protobuf — all languages (base URL only; SDK auto-appends /v1/traces etc.):

export OTEL_EXPORTER_OTLP_ENDPOINT="https://ingress.<CORALOGIX_REGION>.coralogix.com:443"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
export OTEL_SERVICE_NAME="<SERVICE_NAME>"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=<CX_APPLICATION_NAME>,cx.subsystem.name=<CX_SUBSYSTEM_NAME>"

Do NOT include /v1/traces in OTEL_EXPORTER_OTLP_ENDPOINT — the SDK appends the signal path automatically for HTTP/proto, so including it results in double-pathing (/v1/traces/v1/traces). Use signal-specific OTEL_EXPORTER_OTLP_TRACES_ENDPOINT if you need to set the full URL explicitly.

Regional Domains

How to find your region: Your Coralogix platform URL shows the region — e.g. https://dashboard.eu2.coralogix.com → region is eu2, domain is eu2.coralogix.com, OTLP endpoint is ingress.eu2.coralogix.com:443.

Legacy endpoint aliases (old shipper configs only — redirect new setups to the regional form):

If a user shows one of these hostnames, identify their region and replace with ingress.<region>.coralogix.com:443.

Authentication Header

All direct OTLP export to Coralogix requires a Send-Your-Data API key passed as an OTLP header:

Authorization=Bearer <CORALOGIX_API_KEY>

The key is found in the Coralogix platform under Settings → Users and Teams → API Keys. Only Send-Your-Data keys work for telemetry ingestion. Team keys and personal keys do not.

Setting the header per language

Environment variable (Java, Node.js, Go, most gRPC SDK env config):

export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
export OTEL_SERVICE_NAME="<SERVICE_NAME>"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=<CX_APPLICATION_NAME>,cx.subsystem.name=<CX_SUBSYSTEM_NAME>"

Python — URL encoding required in env vars:

export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer%20<CORALOGIX_API_KEY>"
export OTEL_SERVICE_NAME="<SERVICE_NAME>"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=<CX_APPLICATION_NAME>,cx.subsystem.name=<CX_SUBSYSTEM_NAME>"

Note: %20 = space between Bearer and the key value.

Java — env var or JVM system property:

# env var
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
# or JVM property
-Dotel.exporter.otlp.headers="Authorization=Bearer <CORALOGIX_API_KEY>"

Go — programmatic (headers map):

headers: map[string]string{"Authorization": "Bearer " + token}

.NET — programmatic (OTLP options):

options.Endpoint = new Uri("https://ingress.<CORALOGIX_REGION>.coralogix.com:443");
options.Protocol = OtlpExportProtocol.Grpc;
options.Headers = $"Authorization=Bearer {config.ApiKey}";

Coralogix-Specific OTLP Headers

When calling the Coralogix OTLP endpoint directly, you may pass application and subsystem names as OTLP headers in addition to resource attributes. Both mechanisms work; resource attributes are the standard approach:

Prefer setting these as resource attributes (cx.application.name, cx.subsystem.name) in the SDK — they propagate to all signals. Header-based values only reach the signals on that specific exporter.

Endpoint vs Domain — SDK vs Collector

The OTel Collector's coralogix exporter uses domain: eu2.coralogix.com (bare hostname, no ingress. prefix, no port). SDK endpoints use ingress. prefix and port 443. The required format varies by language and protocol.

PrivateLink

When using AWS PrivateLink, replace ingress.<region> with ingress.private.<region>:

ingress.private.eu2.coralogix.com:443

.NET OpenTelemetry Instrumentation

Contents

• Overview
• Auto-Instrumentation (Zero-Code)
• Manual Instrumentation
• Traces
• Metrics
• Logs
• Exception Logging
• Log Framework Bridges (NLog, log4net)
• Kubernetes Injection
• Common Mistakes

Source: Coralogix .NET OpenTelemetry Instrumentation documentation.

Legacy SDK Deprecation

The Coralogix .NET SDKs — Coralogix.SDK (for .NET Framework) and CoralogixCoreSDK (for .NET Core) — are deprecated and reach end-of-life on June 30, 2026. This also covers the Coralogix NLog SDK, log4net SDK, and Serilog SDK. If a user asks about CoralogixLogger, CORALOGIX_LOG_URL, or any Coralogix-branded .NET NuGet package, redirect them to OTel .NET instrumentation immediately. Do not explain how to configure the deprecated SDKs.

See: https://coralogix.com/docs/user-guides/latest-updates/deprecations/dotnet-sdk-deprecation/

Overview

.NET supports: 1. Auto-instrumentation (zero-code) — OpenTelemetry .NET Auto-Instrumentation profiler. 2. Manual instrumentation — explicit TracerProvider, MeterProvider, LoggerProvider via NuGet SDK packages.

Both paths export traces, metrics, and logs to Coralogix via OTLP/gRPC.

Requirements: .NET SDK 8.0 or later (for .NET Framework: 4.6.2 or later).

Auto-Instrumentation (Zero-Code)

The OpenTelemetry .NET Auto-Instrumentation instruments .NET applications without modifying source code.

Required environment variables

export OTEL_TRACES_EXPORTER="otlp"
export OTEL_EXPORTER_OTLP_ENDPOINT="https://ingress.<CORALOGIX_REGION>.coralogix.com:443"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
export OTEL_EXPORTER_OTLP_PROTOCOL="grpc"
export OTEL_SERVICE_NAME="<SERVICE_NAME>"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=<CX_APPLICATION_NAME>,cx.subsystem.name=<CX_SUBSYSTEM_NAME>"

Note: For .NET auto-instrumentation, OTEL_EXPORTER_OTLP_ENDPOINT uses https:// scheme (unlike gRPC where the scheme is normally implicit). Follow the OpenTelemetry .NET Auto-Instrumentation docs for profiler setup and OS-specific installation.

Region values

Replace <CORALOGIX_REGION> with: eu1, eu2, us1, us2, ap1, ap2, or ap3.

Manual Instrumentation

Follow the official OpenTelemetry .NET getting-started guide for SDK installation: https://opentelemetry.io/docs/languages/dotnet/getting-started/

Relevant NuGet package artifacts to name in manual setup answers: OpenTelemetry, OpenTelemetry.Exporter.OpenTelemetryProtocol, OpenTelemetry.Extensions.Hosting, and any signal-specific instrumentation package such as OpenTelemetry.Instrumentation.Runtime. Name the NuGet artifacts, but do not include dotnet add package install commands unless the user explicitly asks for commands.

Important: .NET OTLP exporters require the full https:// URI scheme — use https://ingress.<region>.coralogix.com:443, not the bare host:port form used by Go WithEndpoint and commonly shown in Python/Node.js Coralogix gRPC examples. Java also requires the https:// URI form.

Step 1: Create and configure the app

dotnet new console -n CoralogixOtelExample
cd CoralogixOtelExample

Step 2: Set environment variables

export CORALOGIX_API_KEY="your-send-your-data-key"
export CORALOGIX_SERVICE_NAME="<SERVICE_NAME>"
export CORALOGIX_APP_NAME="<CX_APPLICATION_NAME>"
export CORALOGIX_SUBSYSTEM_NAME="<CX_SUBSYSTEM_NAME>"
export CORALOGIX_DOMAIN="<REGION>"   # e.g. eu2 — do not include .coralogix.com

Step 3: Shared configuration setup

using OpenTelemetry;
using OpenTelemetry.Resources;

private static CoralogixConfig LoadConfiguration()
{
    var domain = Environment.GetEnvironmentVariable("CORALOGIX_DOMAIN") ?? "EU1";
    var apiKey = Environment.GetEnvironmentVariable("CORALOGIX_API_KEY")
        ?? throw new InvalidOperationException("CORALOGIX_API_KEY is required");
    var serviceName = Environment.GetEnvironmentVariable("CORALOGIX_SERVICE_NAME") ?? "dotnet-service";
    var applicationName = Environment.GetEnvironmentVariable("CORALOGIX_APP_NAME") ?? "dotnet-app";
    var subsystemName = Environment.GetEnvironmentVariable("CORALOGIX_SUBSYSTEM_NAME") ?? "default";

    return new CoralogixConfig { Domain = domain, ApiKey = apiKey,
        ServiceName = serviceName, ApplicationName = applicationName, SubsystemName = subsystemName };
}

private static ResourceBuilder BuildResourceAttributes(CoralogixConfig config)
{
    return ResourceBuilder.CreateDefault()
        .AddService(serviceName: config.ServiceName, serviceNamespace: config.ApplicationName)
        .AddAttributes(new Dictionary<string, object>
        {
            ["cx.application.name"] = config.ApplicationName,
            ["cx.subsystem.name"] = config.SubsystemName,
        });
}

// Shared OTLP exporter config
private static void ConfigureOtlpExporter(
    OpenTelemetry.Exporter.OtlpExporterOptions options, CoralogixConfig config)
{
    options.Endpoint = new Uri($"https://ingress.{config.Domain.ToLower()}.coralogix.com:443");
    options.Protocol = OpenTelemetry.Exporter.OtlpExportProtocol.Grpc;
    options.Headers = $"Authorization=Bearer {config.ApiKey}";
}

Traces

No extra package artifact is needed beyond the base NuGet artifacts above for this minimal manual trace example.

using OpenTelemetry.Trace;
using System.Diagnostics;

private static readonly ActivitySource ActivitySource = new("CoralogixOtelExample", "1.0.0");

private static TracerProvider ConfigureTracing(ResourceBuilder resourceBuilder, CoralogixConfig config)
{
    return Sdk.CreateTracerProviderBuilder()
        .SetResourceBuilder(resourceBuilder)
        .AddSource(ActivitySource.Name)
        .AddOtlpExporter(options => ConfigureOtlpExporter(options, config))
        .Build();
}

// Usage in main:
using (var activity = ActivitySource.StartActivity("SampleOperation"))
{
    activity?.SetTag("user.id", "user-123");
    activity?.SetStatus(ActivityStatusCode.Ok);
}
Thread.Sleep(1000); // allow export before process exit

Validation: Coralogix UI → Explore → Tracing.

Metrics

using OpenTelemetry.Metrics;
using System.Diagnostics.Metrics;

private static readonly Meter Meter = new("CoralogixOtelExample", "1.0.0");

private static MeterProvider ConfigureMetrics(ResourceBuilder resourceBuilder, CoralogixConfig config)
{
    return Sdk.CreateMeterProviderBuilder()
        .SetResourceBuilder(resourceBuilder)
        .AddMeter("CoralogixOtelExample")
        .AddRuntimeInstrumentation()
        .AddOtlpExporter(options => ConfigureOtlpExporter(options, config))
        .Build();
}

// Create and record a counter
var requestCounter = Meter.CreateCounter<long>("sample.counter", "requests", "Sample counter");
requestCounter.Add(1, new KeyValuePair<string, object?>("status", "success"));
Thread.Sleep(1000);

Validation: Coralogix Grafana → Explore → Metric Browser.

Logs

using Microsoft.Extensions.Logging;
using OpenTelemetry.Logs;

private static ILoggerFactory ConfigureLogging(ResourceBuilder resourceBuilder, CoralogixConfig config)
{
    return LoggerFactory.Create(builder =>
    {
        builder.SetMinimumLevel(LogLevel.Information);
        builder.AddOpenTelemetry(options =>
        {
            options.SetResourceBuilder(resourceBuilder);
            options.AddOtlpExporter(otlpOptions => ConfigureOtlpExporter(otlpOptions, config));
            options.IncludeFormattedMessage = true;
            options.IncludeScopes = true;
        });
    });
}

// Usage
var logger = loggerFactory.CreateLogger<Program>();
logger.LogInformation("Hello from Coralogix .NET OpenTelemetry!");
logger.LogError(new InvalidOperationException("db failed"), "request failed");
Thread.Sleep(5000); // allow export

Validation: Coralogix UI → Logs.

Exception Logging

Pass the exception object to the logger — do not format it into the message string:

try { /* ... */ }
catch (Exception ex)
{
    logger.LogError(ex, "Could not process item {ItemId}", 42);
}

Requires OpenTelemetry.Exporter.OpenTelemetryProtocol >= 1.8.0 for exception semantic convention support.

Log Framework Bridges (for auto-instrumentation)

NLog bridge

export OTEL_DOTNET_AUTO_LOGS_ENABLED=true
export OTEL_DOTNET_AUTO_LOGS_ENABLE_NLOG_BRIDGE=true

Supported NLog: >= 5.0.0 and < 7.0.0. Available in auto-instrumentation >= 1.14.0.

log4net bridge

export OTEL_DOTNET_AUTO_LOGS_ENABLED=true
export OTEL_DOTNET_AUTO_LOGS_ENABLE_LOG4NET_BRIDGE=true

Supported log4net: >= 2.0.13 and < 4.0.0. Available in auto-instrumentation >= 1.10.0.

If NLog or log4net is already configured as a Microsoft.Extensions.Logging provider, use the Microsoft.Extensions.Logging path instead of enabling the bridge — enabling both causes duplicate logs.

Kubernetes Injection

The OpenTelemetry Operator supports .NET auto-instrumentation injection:

annotations:
  instrumentation.opentelemetry.io/inject-dotnet: "true"

Span Status

.NET does not automatically set span status to Error when an exception is thrown. Without explicit status setting, spanmetrics will report STATUS_CODE_UNSET for all spans including those that caught exceptions — making error-rate metrics unreliable.

Always set span status explicitly in catch blocks:

using (var activity = ActivitySource.StartActivity("ProcessOrder"))
{
    try
    {
        // ... do work ...
        activity?.SetStatus(ActivityStatusCode.Ok);
    }
    catch (Exception ex)
    {
        activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
        activity?.RecordException(ex);
        throw;
    }
}

RecordException attaches the exception as a span event following OTel semantic conventions. Requires OpenTelemetry.Exporter.OpenTelemetryProtocol >= 1.8.0.

Context Propagation (.NET Framework)

.NET 5+ (ASP.NET Core) propagates W3C traceparent on incoming requests automatically via OpenTelemetry.Instrumentation.AspNetCore. Classic .NET Framework (ASP.NET) requires explicit server-side setup. If traces from upstream Node.js or Java services are not continuing into a .NET Framework backend (independent spans created instead of child spans), confirm:

1. OpenTelemetry.Instrumentation.AspNet NuGet package is installed (not the Http package — that instruments outgoing client calls, not incoming requests) 2. .AddAspNetInstrumentation() is called on the TracerProvider so the server reads and continues the incoming traceparent header 3. The upstream service sends W3C format headers (not B3/Zipkin)

Note: AddHttpClientInstrumentation() / OpenTelemetry.Instrumentation.Http instruments outgoing HttpClient calls and does NOT fix broken incoming trace propagation.

Common Mistakes

Go OpenTelemetry Instrumentation

Contents

• Overview
• Prerequisites
• Required environment variables
• Step 1: Initialize Go module and shared setup
• Traces
• Metrics
• Logs (beta)
• Exception Logging
• Common Mistakes

Source: Coralogix Golang OpenTelemetry Instrumentation documentation.

Legacy SDK Deprecation

The Coralogix Go SDK (go-coralogix-sdk, github.com/coralogix/go-coralogix-sdk) is deprecated and reaches end-of-life on June 30, 2026. No bug fixes, security patches, or new features will be provided after that date. If a user asks about go-coralogix-sdk, coralogix.NewCoralogixLogger, or the CORALOGIX_LOG_URL pattern, redirect them to this OpenTelemetry Go instrumentation guide immediately. Do not explain how to configure or use the deprecated SDK.

See: https://coralogix.com/docs/user-guides/latest-updates/deprecations/

Overview

This skill covers manual Go SDK instrumentation. OpenTelemetry also has Go zero-code/eBPF options such as OBI and the Auto SDK, but those are out of scope here.

FIPS / boringcrypto note: Go auto-instrumentation (eBPF/OBI) is incompatible with boringcrypto-compiled (GOEXPERIMENT=boringcrypto) binaries and panics with "invalid semantic version" since v0.21.0. If a user asks why Go auto-instrumentation fails on a FIPS-compliant build, redirect them to this manual SDK guide — it works correctly on FIPS builds. All three signals (traces, metrics, logs) use a shared setup pattern with reusable provider constructors.

Go OTel signal stability:

• Traces: stable
• Metrics: stable
• Logs: beta (API and behavior may change)

Prerequisites

• Go 1.21+
• Coralogix Send-Your-Data API key and OTLP endpoint.

Required environment variables

export OTEL_EXPORTER_OTLP_ENDPOINT="ingress.<CORALOGIX_REGION>.coralogix.com:443"
export CORALOGIX_API_KEY="your-send-your-data-key"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
export OTEL_SERVICE_NAME="<SERVICE_NAME>"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=<CX_APPLICATION_NAME>,cx.subsystem.name=<CX_SUBSYSTEM_NAME>"

Step 1: Initialize Go module and shared setup

Use the official OpenTelemetry Go getting-started guide for SDK installation: https://opentelemetry.io/docs/languages/go/getting-started/

Semconv version must match the installed OTel SDK. The semconv/vX.Y.Z packages are part of the go.opentelemetry.io/otel module — do not add them as separate go.mod require entries. Import the package version that matches SchemaURL used by resource.Default() (same as the otel SDK version). A mismatch panics at runtime with "conflicting Schema URL". To find the right version: check which semconv/v* directories exist under your installed go.opentelemetry.io/otel module in $(go env GOPATH)/pkg/mod.

package main

import (
    "errors"
    "os"

    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/sdk/resource"
    semconv "go.opentelemetry.io/otel/semconv/v1.40.0"  // match your SDK version
)

type OtelSetup struct {
    Resource *resource.Resource
    endpoint string
    headers  map[string]string
}

func Configure() (*OtelSetup, error) {
    endpoint := os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT") // e.g. ingress.eu2.coralogix.com:443
    token := os.Getenv("CORALOGIX_API_KEY")

    if endpoint == "" || token == "" {
        return nil, errors.New("OTEL_EXPORTER_OTLP_ENDPOINT and CORALOGIX_API_KEY must be set")
    }

    res, err := resource.Merge(
        resource.Default(),
        resource.NewWithAttributes(
            semconv.SchemaURL,
            semconv.ServiceName("<SERVICE_NAME>"),
            semconv.ServiceVersion("0.1.0"),
            attribute.String("cx.application.name", "<CX_APPLICATION_NAME>"),
            attribute.String("cx.subsystem.name", "<CX_SUBSYSTEM_NAME>"),
        ),
    )
    if err != nil {
        return nil, err
    }

    return &OtelSetup{
        Resource: res,
        endpoint: endpoint,
        headers:  map[string]string{"Authorization": "Bearer " + token},
    }, nil
}

Traces

Use the official OpenTelemetry Go getting-started guide for trace SDK setup: https://opentelemetry.io/docs/languages/go/getting-started/

Package artifacts used by this trace setup: go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc, go.opentelemetry.io/otel/sdk/trace, google.golang.org/grpc/credentials, and github.com/coralogix/coralogix-opentelemetry-go/sampler. The Coralogix sampler package enables APM Transactions; do not omit it when transactions matter.

import (
    "context"
    "time"

    "github.com/coralogix/coralogix-opentelemetry-go/sampler"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    "google.golang.org/grpc/credentials"
)

func (s *OtelSetup) NewTracerProvider(ctx context.Context) (*sdktrace.TracerProvider, error) {
    exp, err := otlptracegrpc.New(ctx,
        otlptracegrpc.WithEndpoint(s.endpoint),
        otlptracegrpc.WithHeaders(s.headers),
        otlptracegrpc.WithTLSCredentials(credentials.NewTLS(nil)),
        otlptracegrpc.WithTimeout(5*time.Second),
    )
    if err != nil {
        return nil, err
    }

    return sdktrace.NewTracerProvider(
        // CoralogixSampler enables Coralogix APM transactions
        sdktrace.WithSampler(sampler.NewCoralogixSampler(sdktrace.AlwaysSample())),
        sdktrace.WithResource(s.Resource),
        sdktrace.WithSpanProcessor(sdktrace.NewBatchSpanProcessor(exp)),
    ), nil
}

Creating spans

import (
    "go.opentelemetry.io/otel"
    otel_trace "go.opentelemetry.io/otel/trace"
    "go.opentelemetry.io/otel/attribute"
)

const tracerName = "my-service"

func handleRequest(ctx context.Context) {
    tracer := otel.Tracer(tracerName)
    ctx, span := tracer.Start(ctx, "handle-request",
        otel_trace.WithSpanKind(otel_trace.SpanKindServer),
    )
    defer span.End()

    span.SetAttributes(
        attribute.String("http.method", "GET"),
        attribute.String("http.route", "/roll"),
    )
    // ... do work ...
}

Wire up and shutdown

func main() {
    ctx := context.Background()

    setup, err := Configure()
    if err != nil { panic(err) }

    tp, err := setup.NewTracerProvider(ctx)
    if err != nil { panic(err) }
    defer func() {
        if err := tp.Shutdown(ctx); err != nil { fmt.Println(err) }
    }()

    otel.SetTracerProvider(tp)
    // ... register handlers, start server ...
}

Validation: Coralogix UI → Explore → Tracing.

Metrics

Use the official OpenTelemetry Go getting-started guide for metric SDK setup: https://opentelemetry.io/docs/languages/go/getting-started/

Package artifacts used by this metric setup: go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc, go.opentelemetry.io/otel/sdk/metric, and google.golang.org/grpc/credentials. Use credentials.NewTLS(nil) on this exporter too.

import (
    "go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc"
    sdkmetric "go.opentelemetry.io/otel/sdk/metric"
)

func (s *OtelSetup) NewMeterProvider(ctx context.Context) (*sdkmetric.MeterProvider, error) {
    exp, err := otlpmetricgrpc.New(ctx,
        otlpmetricgrpc.WithEndpoint(s.endpoint),
        otlpmetricgrpc.WithHeaders(s.headers),
        otlpmetricgrpc.WithTLSCredentials(credentials.NewTLS(nil)),
        otlpmetricgrpc.WithTimeout(5*time.Second),
    )
    if err != nil {
        return nil, err
    }

    return sdkmetric.NewMeterProvider(
        sdkmetric.WithResource(s.Resource),
        sdkmetric.WithReader(sdkmetric.NewPeriodicReader(exp)),
    ), nil
}

// In main:
otel.SetMeterProvider(mp)
meter := otel.Meter("my-service")
reqCounter, _ := meter.Int64Counter("http.server.requests",
    metric.WithDescription("Total HTTP requests"),
)
reqCounter.Add(ctx, 1, metric.WithAttributes(attribute.String("method", "GET")))

Validation: Coralogix Grafana → Explore → Metric Browser.

Logs (beta)

Use the official OpenTelemetry Go getting-started guide for log SDK setup: https://opentelemetry.io/docs/languages/go/getting-started/

Package artifacts used by this log setup: go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc, go.opentelemetry.io/otel/sdk/log, go.opentelemetry.io/otel/log/global, go.opentelemetry.io/contrib/bridges/otelslog, and google.golang.org/grpc/credentials. Use credentials.NewTLS(nil) on this exporter too.

import (
    "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"
    logsdk "go.opentelemetry.io/otel/sdk/log"
    "go.opentelemetry.io/otel/log/global"
    "go.opentelemetry.io/contrib/bridges/otelslog"
    "log/slog"
)

func (s *OtelSetup) NewLoggerProvider(ctx context.Context) (*logsdk.LoggerProvider, error) {
    exp, err := otlploggrpc.New(ctx,
        otlploggrpc.WithEndpoint(s.endpoint),
        otlploggrpc.WithHeaders(s.headers),
        otlploggrpc.WithTLSCredentials(credentials.NewTLS(nil)),
        otlploggrpc.WithTimeout(5*time.Second),
    )
    if err != nil {
        return nil, err
    }
    return logsdk.NewLoggerProvider(
        logsdk.WithResource(s.Resource),
        logsdk.WithProcessor(logsdk.NewBatchProcessor(exp)),
    ), nil
}

// Wire slog bridge in main:
global.SetLoggerProvider(lp)
h := otelslog.NewHandler("my-app", otelslog.WithLoggerProvider(lp))
slog.SetDefault(slog.New(h))

slog.Info("Hello from Coralogix Go OTel")

Validation: Coralogix UI → Logs.

Exception Logging

import "go.opentelemetry.io/otel/log"

func emitException(ctx context.Context, logger log.Logger) {
    err := errors.New("database connection failed")
    record := log.Record{}
    record.SetSeverity(log.SeverityError)
    record.SetBody(log.StringValue("request failed"))
    record.SetErr(err)   // available in go.opentelemetry.io/otel/log >= v0.18.0
    logger.Emit(ctx, record)
}

Using otelzap bridge

Use the official OpenTelemetry Go documentation for bridge installation details: https://opentelemetry.io/docs/languages/go/getting-started/

core := otelzap.NewCore("my-app", otelzap.WithLoggerProvider(lp))
logger := zap.New(core)
logger.Error("request failed", zap.Error(errors.New("db failed")))

Use zap.Error(err) — named errors like zap.NamedError("db", err) emit as regular attributes, not exception semantic convention fields.

Common Mistakes

Java OpenTelemetry Instrumentation

Contents

• Overview
• Auto-Instrumentation
• Additional Instrumentation with @WithSpan
• Exception Logging
• Enabling Metrics and Logs
• Verification
• Common Mistakes
• Kubernetes Injection

Source: Coralogix Java OpenTelemetry Instrumentation documentation.

Overview

Java instrumentation uses the OpenTelemetry Java Agent — a JAR that attaches to any Java 8+ application and injects bytecode to capture telemetry automatically. No manual SDK init code is required for auto-instrumentation. Manual span additions use the @WithSpan annotation while the agent is attached.

Use the latest stable OpenTelemetry Java agent from the releases page.

Auto-Instrumentation

Step 1: Follow the OpenTelemetry Java setup guide

Use the official OpenTelemetry Java getting-started guide for SDK and agent installation: https://opentelemetry.io/docs/languages/java/getting-started/

Distribute the JAR to each service host or container that needs instrumentation. The JVM must have access to the JAR at startup.

Step 2: Set environment variables (recommended)

export JAVA_TOOL_OPTIONS="-javaagent:/path/to/opentelemetry-javaagent.jar"

export OTEL_TRACES_EXPORTER="otlp"
export OTEL_METRICS_EXPORTER="none"         # set to "otlp" to enable metrics
export OTEL_LOGS_EXPORTER="none"            # set to "otlp" to enable logs
export OTEL_EXPORTER_OTLP_TRACES_PROTOCOL="grpc"
export OTEL_EXPORTER_OTLP_ENDPOINT="https://ingress.<CORALOGIX_REGION>.coralogix.com:443"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
export OTEL_SERVICE_NAME="<SERVICE_NAME>"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=<CX_APPLICATION_NAME>,cx.subsystem.name=<CX_SUBSYSTEM_NAME>"

java -jar myapp.jar

Step 2 (alternative): JVM system properties

java -javaagent:/path/to/opentelemetry-javaagent.jar \
    -Dotel.traces.exporter=otlp \
    -Dotel.metrics.exporter=none \
    -Dotel.logs.exporter=none \
    -Dotel.exporter.otlp.traces.protocol=grpc \
    -Dotel.exporter.otlp.traces.endpoint="https://ingress.<CORALOGIX_REGION>.coralogix.com:443" \
    -Dotel.exporter.otlp.traces.headers="Authorization=Bearer <CORALOGIX_API_KEY>" \
    -Dotel.service.name="<SERVICE_NAME>" \
    -Dotel.resource.attributes="cx.application.name=<CX_APPLICATION_NAME>,cx.subsystem.name=<CX_SUBSYSTEM_NAME>" \
    -jar myapp.jar

Resource attributes note

Use the current identity attributes consistently:

service.name=<SERVICE_NAME>
cx.application.name=<CX_APPLICATION_NAME>
cx.subsystem.name=<CX_SUBSYSTEM_NAME>

Additional Instrumentation with @WithSpan

While the agent handles framework-level spans, you can add custom spans to any method using the @WithSpan annotation without touching the tracer API.

Dependency reference

Use the official OpenTelemetry Java getting-started guide for dependency setup: https://opentelemetry.io/docs/languages/java/getting-started/

Required package artifact for @WithSpan: opentelemetry-instrumentation-annotations. Name this artifact explicitly when explaining custom spans, but do not include install commands unless the user asks for them.

Usage

import io.opentelemetry.instrumentation.annotations.WithSpan;

public class CartService {
    @WithSpan  // creates a span named "CartService.addItem" automatically
    public void addItem(String itemId) {
        // method body — span auto-closes when method returns
    }
}

The @WithSpan annotation only creates spans when the agent is running. Without the agent, the annotation is a no-op.

Exception Logging

Via OpenTelemetry Logs API

import io.opentelemetry.api.logs.Logger;
import io.opentelemetry.api.logs.Severity;

logger.logRecordBuilder()
    .setSeverity(Severity.ERROR)
    .setBody("request failed")
    .setException(new IllegalStateException("database connection failed"))
    .emit();

Via Log4j 2 appender (opentelemetry-log4j-appender-2.17)

Use the official OpenTelemetry Java getting-started guide for appender dependency setup: https://opentelemetry.io/docs/languages/java/getting-started/

log4j2.xml:

<Configuration>
  <Appenders>
    <OpenTelemetry name="OpenTelemetryAppender"/>
  </Appenders>
  <Loggers>
    <Root level="all">
      <AppenderRef ref="OpenTelemetryAppender"/>
    </Root>
  </Loggers>
</Configuration>

import io.opentelemetry.instrumentation.log4j.appender.v2_17.OpenTelemetryAppender;
// Call once at startup:
OpenTelemetryAppender.install(openTelemetry);

Enabling Metrics and Logs

By default, only traces are enabled in the examples. To enable metrics and/or logs:

export OTEL_METRICS_EXPORTER="otlp"   # enables metrics
export OTEL_LOGS_EXPORTER="otlp"      # enables logs (requires log bridge setup)

Verification

1. Start the application with the agent attached. 2. Look for this log line confirming agent attachment:

   [otel.javaagent ...] INFO io.opentelemetry.javaagent.tooling.VersionLogger - opentelemetry-javaagent - version: <agent-version>

3. Generate traffic to the application. 4. In Coralogix UI: Explore → Tracing — traces should appear within ~30 seconds. 5. If metrics are enabled: Grafana → Explore → Metric Browser.

Common Mistakes

Kubernetes Injection

The OpenTelemetry Operator supports injection of the Java agent into pods via the Instrumentation CRD — no JAR download or JAVA_TOOL_OPTIONS needed in the pod spec. Do NOT instruct users to set JAVA_TOOL_OPTIONS or download the JAR manually when the Operator is in use — those steps are bypassed by the injector.

Option A: via OTel Collector (recommended for Kubernetes — collector handles auth and enrichment):

apiVersion: opentelemetry.io/v1alpha1
kind: Instrumentation
metadata:
  name: coralogix-instrumentation
spec:
  exporter:
    endpoint: http://otel-collector.monitoring.svc.cluster.local:4317
  java:
    image: ghcr.io/open-telemetry/opentelemetry-operator/autoinstrumentation-java:latest

Option B: direct to Coralogix (auth headers injected via spec.env):

apiVersion: opentelemetry.io/v1alpha1
kind: Instrumentation
metadata:
  name: coralogix-instrumentation
spec:
  exporter:
    endpoint: https://ingress.<CORALOGIX_REGION>.coralogix.com:443
  env:
    - name: OTEL_EXPORTER_OTLP_HEADERS
      value: "Authorization=Bearer <CORALOGIX_API_KEY>"
    - name: OTEL_SERVICE_NAME
      value: "<SERVICE_NAME>"
    - name: OTEL_RESOURCE_ATTRIBUTES
      value: "cx.application.name=<CX_APPLICATION_NAME>,cx.subsystem.name=<CX_SUBSYSTEM_NAME>"
  java:
    image: ghcr.io/open-telemetry/opentelemetry-operator/autoinstrumentation-java:latest

Opt in via pod annotation:

annotations:
  instrumentation.opentelemetry.io/inject-java: "true"

The agent env vars (OTEL_EXPORTER_OTLP_*, OTEL_RESOURCE_ATTRIBUTES) are injected automatically from the Instrumentation CRD spec. For Option B, use a Kubernetes Secret for the API key value rather than a plain-text value: field.

Language Selector — Decision Tree

Contents

• Step 1: Identify the Target Language / Runtime
• Step 2: Identify Telemetry Signals
• Step 3: Identify Instrumentation Mode
• Step 4: Identify Export Path
• Step 5: Collect Required Variables

Use this file to identify the language, signal, instrumentation mode, and export path before loading any language-specific reference. Walk each decision in order.

Step 1: Identify the Target Language / Runtime

Step 1b: Matrix when language is unknown

Step 2: Identify Telemetry Signals

Ask or infer which signals the user needs:

Step 3: Identify Instrumentation Mode

Mode notes by language

Java: Coralogix guidance emphasizes the Java agent plus @WithSpan annotation-based span additions. Upstream OpenTelemetry Java also supports pure SDK manual instrumentation, but that path is not the default Coralogix setup in this skill.

Python: Three distinct paths are documented: auto (opentelemetry-instrument wrapper), programmatic (SDK init inside app + FlaskInstrumentor), and manual (explicit tracer/span creation). All three can use CoralogixTransactionSampler from coralogix-opentelemetry.

Node.js: Bundled auto (@opentelemetry/auto-instrumentations-node via NODE_OPTIONS) vs individual auto (custom instrumentation.js with chosen libraries). Bundled does NOT support Coralogix transactions — use individual or manual for transaction support.

Go: This skill covers manual SDK instrumentation. Go zero-code/eBPF options exist, but they are out of scope for this SDK instrumentation skill.

Step 4: Identify Export Path

Do not make a final recommendation until you know the user's scale, runtime, deployment environment, enrichment needs, retry/buffering requirements, and sampling needs.

Export path tradeoffs

Step 5: Collect Required Variables

Before generating any code or config, confirm these are known (or use placeholders):

If the region is unknown, instruct the user to find it from their Coralogix platform URL: https://dashboard.<region>.coralogix.com → the region is the subdomain prefix before .coralogix.com. Always load coralogix-endpoints.md when generating endpoint config.

Node.js OpenTelemetry Instrumentation

Contents

• Overview
• Required packages
• Bundled Auto-Instrumentation
• Individual Auto-Instrumentation (supports Coralogix transactions)
• Manual Instrumentation
• Exception Logging
• Kubernetes Injection
• Common Mistakes

Source: Coralogix Node.js OpenTelemetry Instrumentation documentation.

Legacy SDK Deprecation

The Coralogix Node.js SDK (coralogix-logger, @coralogix/coralogix-sdk) and the Coralogix Winston and Bunyan integrations are deprecated and reach end-of-life on June 30, 2026. The official Coralogix Node.js SDK docs page has already been rewritten to show OpenTelemetry as the replacement. If a user asks about coralogix-logger, the Coralogix Winston integration, or the Coralogix Bunyan integration, redirect them to OTel Node.js instrumentation immediately. Do not explain how to configure the deprecated packages.

See: https://coralogix.com/docs/user-guides/latest-updates/deprecations/

Prerequisites

• Node.js ^18.19.0 || >=20.6.0 (required by OTel JS SDK 2.x — Node 14/16 are not supported)
• Coralogix Send-Your-Data API key and region/domain.

Overview

Node.js supports three approaches:

1. Bundled auto-instrumentation — loads all available auto-instrumentation libraries via NODE_OPTIONS. 2. Individual auto-instrumentation — custom instrumentation.js with chosen libraries. 3. Manual instrumentation — explicit BasicTracerProvider + span creation.

Coralogix transactions caveat: Bundled auto-instrumentation is NOT supported for Coralogix transactions (APM → Transactions view). Use individual auto-instrumentation or manual instrumentation to enable CoralogixTransactionSampler.

Required packages

Use the official OpenTelemetry Node.js getting-started guide for SDK installation: https://opentelemetry.io/docs/languages/js/getting-started/nodejs/

For Coralogix APM Transactions, include @coralogix/opentelemetry in the same dependency management flow.

Bundled Auto-Instrumentation

Set environment variables and use NODE_OPTIONS to load the registration library:

export OTEL_TRACES_EXPORTER="otlp"
export OTEL_EXPORTER_OTLP_PROTOCOL="grpc"
export OTEL_EXPORTER_OTLP_COMPRESSION="gzip"
# gRPC endpoint: bare host:port is the standard Coralogix form; https://host:port is also accepted
export OTEL_EXPORTER_OTLP_ENDPOINT="ingress.<CORALOGIX_REGION>.coralogix.com:443"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
export OTEL_NODE_RESOURCE_DETECTORS="all"
export OTEL_SERVICE_NAME="<SERVICE_NAME>"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=<CX_APPLICATION_NAME>,cx.subsystem.name=<CX_SUBSYSTEM_NAME>"

node --require @opentelemetry/auto-instrumentations-node/register YourApp.js

Or using NODE_OPTIONS:

export NODE_OPTIONS="--require @opentelemetry/auto-instrumentations-node/register"
node YourApp.js

Reminder: Env vars cannot be set inside the application code — they must be available before the auto-instrumentation library starts at process startup.

Limitation: Bundled auto-instrumentation does NOT support Coralogix transactions. Switch to individual method below if transactions are needed.

ESM apps (using `import` syntax): --require does not fire for ES modules — auto-instrumentation silently does nothing. Use --import plus the loader hook instead:

node --experimental-loader=@opentelemetry/instrumentation/hook.mjs \
     --import @opentelemetry/auto-instrumentations-node/register YourApp.mjs

Individual Auto-Instrumentation (supports Coralogix transactions)

Create an instrumentation.js file:

// instrumentation.js
const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http');
const { ExpressInstrumentation } = require('@opentelemetry/instrumentation-express');
const opentelemetry = require("@opentelemetry/sdk-node");
const { CoralogixTransactionSampler } = require("@coralogix/opentelemetry");
const { AlwaysOnSampler } = require("@opentelemetry/sdk-trace-base");

// Exporter is configured via env vars (OTEL_TRACES_EXPORTER, OTEL_EXPORTER_OTLP_PROTOCOL,
// OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_HEADERS) — same as the bundled approach.
const sdk = new opentelemetry.NodeSDK({
  sampler: new CoralogixTransactionSampler(new AlwaysOnSampler()),
  instrumentations: [
    new HttpInstrumentation(),
    new ExpressInstrumentation(),
    // add more individual instrumentation libraries as needed
  ],
});

sdk.start();

Use the same environment variables as bundled (above), then run:

node --require ./instrumentation.js YourApp.js

This approach allows CoralogixTransactionSampler to be wired into the sampler chain, enabling Coralogix Transactions support.

Manual Instrumentation

Full manual control over span creation using NodeTracerProvider:

const opentelemetry = require('@opentelemetry/api');
const { resourceFromAttributes } = require('@opentelemetry/resources');
const { ATTR_SERVICE_NAME } = require('@opentelemetry/semantic-conventions');
const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
const { SimpleSpanProcessor, AlwaysOnSampler } = require('@opentelemetry/sdk-trace-base');
const { OTLPTraceExporter } = require("@opentelemetry/exporter-trace-otlp-proto");
const { CoralogixTransactionSampler } = require('@coralogix/opentelemetry');

const exporter = new OTLPTraceExporter({
  timeoutMillis: 15000,
  // HTTP/proto exporter requires /v1/traces path
  url: 'https://ingress.<CORALOGIX_REGION>.coralogix.com:443/v1/traces',
  headers: {
    Authorization: `Bearer ${process.env.CORALOGIX_API_KEY}`,
  },
});

const provider = new NodeTracerProvider({
  resource: resourceFromAttributes({
    [ATTR_SERVICE_NAME]: '<SERVICE_NAME>',
    'cx.application.name': '<CX_APPLICATION_NAME>',
    'cx.subsystem.name': '<CX_SUBSYSTEM_NAME>',
  }),
  sampler: new CoralogixTransactionSampler(new AlwaysOnSampler()),
  spanProcessors: [new SimpleSpanProcessor(exporter)],
});

provider.register();

// Graceful shutdown
['SIGINT', 'SIGTERM'].forEach(signal => {
  process.on(signal, () => provider.shutdown().catch(console.error));
});

const tracer = opentelemetry.trace.getTracer('<SERVICE_NAME>');
const span = tracer.startSpan('main');
// ... do work ...
span.end();

Required package artifacts for manual

Name these package artifacts when explaining the manual setup, but use the official OpenTelemetry Node.js getting-started guide for installation details and current versions:

• @opentelemetry/api
• @opentelemetry/exporter-trace-otlp-proto
• @opentelemetry/resources
• @opentelemetry/sdk-trace-base
• @opentelemetry/sdk-trace-node
• @coralogix/opentelemetry

Exception Logging

const { logs, SeverityNumber } = require('@opentelemetry/api-logs');
const { LoggerProvider, SimpleLogRecordProcessor } = require('@opentelemetry/sdk-logs');

const loggerProvider = new LoggerProvider({
  processors: [new SimpleLogRecordProcessor(/* add OTLP exporter here */)],
});
logs.setGlobalLoggerProvider(loggerProvider);

const logger = logs.getLogger('my-logger', '1.0.0');
const error = new Error('database connection failed');
logger.emit({
  severityNumber: SeverityNumber.ERROR,
  severityText: 'ERROR',
  body: 'request failed',
  exception: error,
});

Exception support requires @opentelemetry/api-logs and @opentelemetry/sdk-logs >= 0.212.0.

Kubernetes Injection

The OpenTelemetry Operator supports Node.js auto-instrumentation injection:

annotations:
  instrumentation.opentelemetry.io/inject-nodejs: "true"

Context Propagation

OTel Node.js propagates W3C traceparent headers automatically on outgoing HTTP requests via @opentelemetry/instrumentation-http. To verify propagation is working:

1. Enable SDK debug logging — look for traceparent in outgoing request headers in the output 2. Confirm the downstream service uses W3C TraceContext propagator (not B3/Zipkin only) 3. Verify intermediaries (load balancers, API gateways) are not stripping traceparent

If the downstream service creates independent spans despite receiving traceparent:

• .NET Framework backends need OpenTelemetry.Instrumentation.AspNet + AddAspNetInstrumentation() on the server-side TracerProvider to read incoming traceparent headers (AddHttpClientInstrumentation instruments outgoing calls, not incoming)
• Java Spring backends need opentelemetry-spring-webmvc-instrumentation on the receiver
• Some frameworks require TextMapPropagator to be configured explicitly to read the header

Common Mistakes

Output Templates

Contents

• Template 1: New Instrumentation Setup
• Template 2: Code Review
• Template 3: Troubleshooting
• Complete Examples (per-language)
• Formatting rules for all templates

Use these templates when generating a final user-facing instrumentation answer. Choose the appropriate template based on the request type.

Template 1: New Instrumentation Setup

Use for: "How do I instrument my X app with OpenTelemetry to send to Coralogix?"

---

Assumptions

• Language: <language>
• Signal(s): <traces | metrics | logs | all>
• Instrumentation mode: <auto | programmatic | manual>
• Export path: <direct to Coralogix | via OTel Collector>
• Coralogix region: <region> (e.g. eu2)
• Framework: <framework if known>

Required inputs (use placeholders)

• CORALOGIX_API_KEY — Send-Your-Data API key from Settings → API Keys
• <SERVICE_NAME> — your service name (appears in APM service map)
• <CX_APPLICATION_NAME> — Coralogix application name (groups services)
• <CX_SUBSYSTEM_NAME> — Coralogix subsystem name (refines routing)

Install reference

• Link to https://opentelemetry.io/docs/languages/<language>/getting-started/ for SDK installation.

Environment variables

# All required env vars with placeholders
# HTTP/protobuf — base URL only; SDK auto-appends /v1/traces, /v1/metrics, /v1/logs
export OTEL_EXPORTER_OTLP_ENDPOINT="https://ingress.<CORALOGIX_REGION>.coralogix.com:443"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
# gRPC endpoint: standard bare form for Python/Node.js/Go; Java/.NET use https://host:port
# export OTEL_EXPORTER_OTLP_ENDPOINT="ingress.<CORALOGIX_REGION>.coralogix.com:443"
# Python exception: URL-encode the space in env-var headers
# export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer%20<CORALOGIX_API_KEY>"
export OTEL_SERVICE_NAME="<SERVICE_NAME>"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=<CX_APPLICATION_NAME>,cx.subsystem.name=<CX_SUBSYSTEM_NAME>"

Code / config snippet

# Minimal working example — copy, paste, replace placeholders

Run command

# How to start the instrumented application

Validation steps 1. Start the application and generate some traffic. 2. Traces → Coralogix UI Explore → Tracing (allow ~30s for first trace). 3. Metrics (if enabled) → Grafana → Explore → Metric Browser. 4. Logs (if enabled) → Coralogix UI Logs.

Security reminders

• Never commit the CORALOGIX_API_KEY value to source control. Use a secrets manager or env var.
• Rotate Send-Your-Data keys if they are exposed.

---

Template 2: Code Review

Use for: "Review my OTel instrumentation code" or "What am I missing?"

---

Review findings for `<language>` instrumentation

Issues found 1. <specific issue and fix> 2. <specific issue and fix>

Corrected snippet

# Corrected minimal working code

---

Template 3: Troubleshooting

Use for: "I'm not seeing any traces / metrics / logs in Coralogix."

---

Troubleshooting: missing `<signal>` from `<language>` app

Load troubleshooting.md for the full symptom table. Quick checklist:

1. Enable SDK debug logging — see troubleshooting.md for per-language instructions. 2. Verify endpoint — is OTEL_EXPORTER_OTLP_ENDPOINT set to https://ingress.<region>.coralogix.com:443/v1/traces for HTTP/protobuf or ingress.<region>.coralogix.com:443 for gRPC? 3. Verify auth — does OTEL_EXPORTER_OTLP_HEADERS contain Authorization=Bearer <key>? 4. Verify region — does the region match the Coralogix account's region? 5. Check for Python URL encoding — is the header value URL encoded (%20 not space)? 6. Check network — can the app reach ingress.<region>.coralogix.com:443? 7. Check signal is enabled — are trace/metric/log exporters set (not "none")? 8. Check correlation and safety — do logs include trace/span context, and are sensitive fields excluded?

---

Complete Examples (per-language)

Use these as the basis for Template 1 answers. Replace eu2 with the user's actual region. All examples send traces only (direct to Coralogix, gRPC). Enable metrics/logs by changing the exporter env vars per the language reference.

---

Java — auto-instrumentation, traces, EU2

export JAVA_TOOL_OPTIONS="-javaagent:/path/to/opentelemetry-javaagent.jar"
export OTEL_TRACES_EXPORTER="otlp"
export OTEL_METRICS_EXPORTER="none"
export OTEL_LOGS_EXPORTER="none"
export OTEL_EXPORTER_OTLP_TRACES_PROTOCOL="grpc"
export OTEL_EXPORTER_OTLP_ENDPOINT="https://ingress.eu2.coralogix.com:443"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
export OTEL_SERVICE_NAME="order-service"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=ecommerce,cx.subsystem.name=orders"
java -jar myapp.jar

Validation: Coralogix UI → Explore → Tracing (look for [otel.javaagent ...] log line at startup).

---

Python — auto-instrumentation, traces, EU2

export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer%20<CORALOGIX_API_KEY>"
export OTEL_EXPORTER_OTLP_ENDPOINT="ingress.eu2.coralogix.com:443"
export OTEL_TRACES_EXPORTER="otlp_proto_grpc"
export OTEL_SERVICE_NAME="order-service"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=ecommerce,cx.subsystem.name=orders"
opentelemetry-instrument python app.py

Note: %20 in OTEL_EXPORTER_OTLP_HEADERS is the URL-encoded space — required for Python env var auth. Do not use %20 in programmatic code.

Validation: Coralogix UI → Explore → Tracing.

---

Node.js — individual auto-instrumentation with Coralogix transactions, EU2

instrumentation.js:

const { NodeSDK } = require('@opentelemetry/sdk-node');
const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http');
const { ExpressInstrumentation } = require('@opentelemetry/instrumentation-express');
const { CoralogixTransactionSampler } = require('@coralogix/opentelemetry');
const { AlwaysOnSampler } = require('@opentelemetry/sdk-trace-base');

const sdk = new NodeSDK({
  sampler: new CoralogixTransactionSampler(new AlwaysOnSampler()),
  instrumentations: [new HttpInstrumentation(), new ExpressInstrumentation()],
});
sdk.start();

export OTEL_EXPORTER_OTLP_PROTOCOL="grpc"
export OTEL_EXPORTER_OTLP_ENDPOINT="ingress.eu2.coralogix.com:443"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
export OTEL_SERVICE_NAME="order-service"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=ecommerce,cx.subsystem.name=orders"
node --require ./instrumentation.js app.js

Validation: Coralogix UI → Explore → Tracing; APM → Transactions (requires CoralogixTransactionSampler).

---

.NET — auto-instrumentation (zero-code), traces, EU2

export OTEL_TRACES_EXPORTER="otlp"
export OTEL_EXPORTER_OTLP_ENDPOINT="https://ingress.eu2.coralogix.com:443"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <CORALOGIX_API_KEY>"
export OTEL_EXPORTER_OTLP_PROTOCOL="grpc"
export OTEL_SERVICE_NAME="order-service"
export OTEL_RESOURCE_ATTRIBUTES="cx.application.name=ecommerce,cx.subsystem.name=orders"

Run the OpenTelemetry .NET Auto-Instrumentation profiler per the official docs.

Validation: Coralogix UI → Explore → Tracing.

---

Go — manual SDK, traces, EU2

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/coralogix/coralogix-opentelemetry-go/sampler"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
    "google.golang.org/grpc/credentials"
)

func main() {
    ctx := context.Background()
    endpoint := os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT") // ingress.eu2.coralogix.com:443
    token := os.Getenv("CORALOGIX_API_KEY")

    res, _ := resource.Merge(resource.Default(), resource.NewWithAttributes(
        semconv.SchemaURL,
        semconv.ServiceName("order-service"),
        attribute.String("cx.application.name", "ecommerce"),
        attribute.String("cx.subsystem.name", "orders"),
    ))

    exp, _ := otlptracegrpc.New(ctx,
        otlptracegrpc.WithEndpoint(endpoint),
        otlptracegrpc.WithHeaders(map[string]string{"Authorization": "Bearer " + token}),
        otlptracegrpc.WithTLSCredentials(credentials.NewTLS(nil)),
    )

    tp := sdktrace.NewTracerProvider(
        sdktrace.WithSampler(sampler.NewCoralogixSampler(sdktrace.AlwaysSample())),
        sdktrace.WithResource(res),
        sdktrace.WithSpanProcessor(sdktrace.NewBatchSpanProcessor(exp)),
    )
    defer tp.Shutdown(ctx)
    otel.SetTracerProvider(tp)

    tracer := otel.Tracer("order-service")
    _, span := tracer.Start(ctx, "process-order")
    span.SetAttributes(attribute.String("order.id", "42"))
    // ... do work ...
    span.End()
    fmt.Println("done")
}

export OTEL_EXPORTER_OTLP_ENDPOINT="ingress.eu2.coralogix.com:443"
export CORALOGIX_API_KEY="your-send-your-data-key"
go run main.go

Validation: Coralogix UI → Explore → Tracing.

---

Formatting rules for all templates

• Always use code blocks with the correct language identifier.
• Replace {{ endpoints.opentelemetry }} template variables (from the docs source) with

the actual regional endpoint. Use the base URL for OTEL_EXPORTER_OTLP_ENDPOINT — do NOT include /v1/traces in the base env var (SDK appends signal path automatically for HTTP/proto):

• gRPC Java/.NET: https://ingress.<CORALOGIX_REGION>.coralogix.com:443
• gRPC Python/Node.js: ingress.<CORALOGIX_REGION>.coralogix.com:443
• gRPC Go WithEndpoint: ingress.<CORALOGIX_REGION>.coralogix.com:443 (bare only)
• HTTP/proto OTEL_EXPORTER_OTLP_ENDPOINT: https://ingress.<CORALOGIX_REGION>.coralogix.com:443
• HTTP/proto programmatic exporter URL: https://ingress.<CORALOGIX_REGION>.coralogix.com:443/v1/traces
• For the API key, reference <CORALOGIX_API_KEY> (shell) or os.environ["CORALOGIX_API_KEY"] (code) — never generate example key values.
• Use inline comments in code blocks only where the line is non-obvious.
• Include validation steps in every new instrumentation answer.
• Keep the "security reminder" section — teams often overlook secret management.
• Do not document SDK installation steps inline; link to the official OpenTelemetry language

getting-started page.

Troubleshooting — SDK Instrumentation to Coralogix

Contents

• Symptom → Root Cause Table
• Enable SDK Debug Logging
• Connectivity Check
• Decision Flow
• Out-of-Scope Issues

Use this reference for "no data", "missing traces", "missing metrics", or "missing logs" reports from the application SDK side (not collector-side issues).

Symptom → Root Cause Table

Enable SDK Debug Logging

Debug logging from the OTel SDK is the fastest way to see what is happening at export time.

Java

export OTEL_LOG_LEVEL=debug
# or JVM property:
-Dotel.log.level=debug

Look for io.opentelemetry.exporter.otlp log messages showing export attempts.

Python

export OTEL_PYTHON_LOG_LEVEL=debug

Or in code before setting up providers:

import logging
logging.basicConfig(level=logging.DEBUG)

Node.js

const { diag, DiagConsoleLogger, DiagLogLevel } = require('@opentelemetry/api');
diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG);

Add this before any SDK initialization.

.NET

export OTEL_LOG_LEVEL=debug

For SDK self-diagnostics, create OTEL_DIAGNOSTICS.json in the process working directory:

{
  "LogDirectory": ".",
  "FileSize": 32768,
  "LogLevel": "Warning",
  "FormatMessage": "true"
}

Or configure application logging via appsettings.json for ASP.NET Core:

{
  "Logging": {
    "LogLevel": {
      "OpenTelemetry": "Debug"
    }
  }
}

Go

The Go SDK does not have a built-in env var for debug logging. Use the OTel error handler:

otel.SetErrorHandler(otel.ErrorHandlerFunc(func(err error) {
    fmt.Fprintf(os.Stderr, "OTEL error: %v\n", err)
}))

Connectivity Check

Test OTLP endpoint reachability from the application host:

# Check TCP connectivity to the OTLP gRPC endpoint
nc -zv ingress.<CORALOGIX_REGION>.coralogix.com 443

# Or with curl (HTTP/proto)
curl -v https://ingress.<CORALOGIX_REGION>.coralogix.com:443/v1/traces \
  -H "Authorization: Bearer <CORALOGIX_API_KEY>" \
  -H "Content-Type: application/x-protobuf" \
  -d "" 2>&1 | head -20

A 400 response from Coralogix (empty body) confirms connectivity and auth work. A timeout or connection refused points to a network or firewall issue.

Decision Flow

No data in Coralogix?
│
├─ Is this a short-lived Python script (exits in under a second)?
│   ├─ Traces missing → BatchSpanProcessor queues spans on a background timer and silently drops
│   │   them if the process exits before the timer fires; use SimpleSpanProcessor instead
│   └─ Metrics missing → PeriodicExportingMetricReader only exports on its configured interval
│       (default 60 s); a script that exits before the interval fires exports zero metrics;
│       fix: call metric_reader.force_flush() before provider.shutdown(), or sleep past the interval
│
├─ Does SDK debug log show export attempts?
│   ├─ No → SDK not initialized or signal exporter = "none" → fix init / exporter config
│   └─ Yes → export errors shown?
│       ├─ 401/403 → wrong key or malformed auth header
│       ├─ timeout/refused → network, firewall, wrong endpoint
│       └─ No errors, 0 spans exported → nothing instrumented; no traffic; sampler dropping all
│
├─ Is OTEL_EXPORTER_OTLP_ENDPOINT correct?
│   Format: https://ingress.<region>.coralogix.com:443 (Java/.NET gRPC),
│   ingress.<region>.coralogix.com:443 (standard Python/Node.js/Go gRPC),
│   or https://....:443/v1/traces (HTTP/protobuf)
│
├─ Is OTEL_EXPORTER_OTLP_HEADERS correct?
│   Format: Authorization=Bearer <key>
│   Python: Authorization=Bearer%20<key> (URL-encoded space)
│
├─ Are service identity attributes present?
│   Check OTEL_SERVICE_NAME plus cx.application.name and cx.subsystem.name in OTEL_RESOURCE_ATTRIBUTES
│
├─ Is telemetry safe and queryable?
│   Avoid sensitive data, keep span names low-cardinality, and keep metric labels bounded
│
└─ Is the region correct?
    Check: Coralogix platform URL → dashboard.<region>.coralogix.com

Out-of-Scope Issues

If the SDK is exporting successfully (no export errors, data visible in Coralogix) but:

• Data is missing enrichment (no pod name, no namespace) — this is a collector-side or

k8sattributes issue; use the opentelemetry-collector skill.

• Broken distributed trace propagation (downstream creates independent spans despite receiving traceparent) — check that all services use W3C TraceContext propagator; .NET Framework needs OpenTelemetry.Instrumentation.AspNet + AddAspNetInstrumentation() on the receiving service (not AddHttpClientInstrumentation, which only covers outgoing calls); verify intermediaries (load balancers, API gateways) are not stripping the traceparent header.
• Span data is malformed (wrong span kind, missing parent) — instrumentation library or propagator configuration issue in the app, not a Coralogix issue.
• Platform features not working (APM service map incomplete, Infrastructure Explorer

empty) — verify resource attributes first; then check collector config.