Managed Service for OpenTelemetry:Report Go application data with Jaeger

Option A: Direct reporting with the Jaeger SDK

Create a tracer that sends spans over HTTP directly to the Managed Service for OpenTelemetry endpoint:

import (
    "io"

    "github.com/opentracing/opentracing-go"
    "github.com/uber/jaeger-client-go"
    "github.com/uber/jaeger-client-go/transport"
)

func NewJaegerTracer(service string) (opentracing.Tracer, io.Closer) {
    sender := transport.NewHTTPTransport(
        // Replace with the endpoint from the Access point information tab.
        // Use a VPC endpoint for production; use a public endpoint otherwise.
        "<endpoint>",
    )

    tracer, closer := jaeger.NewTracer(
        service,
        jaeger.NewConstSampler(true),
        jaeger.NewRemoteReporter(sender),
    )
    return tracer, closer
}

Replace the following placeholder with your actual value:

Option B: Reporting through the Jaeger agent

Before you create the tracer, install and start the Jaeger agent. See Install the Jaeger agent.

Then create a tracer that sends spans over UDP to the local agent:

import (
    "io"

    "github.com/opentracing/opentracing-go"
    "github.com/uber/jaeger-client-go"
)

func NewJaegerTracer(serviceName string) (opentracing.Tracer, io.Closer) {
    sender, _ := jaeger.NewUDPTransport("", 0)

    tracer, closer := jaeger.NewTracer(
        serviceName,
        jaeger.NewConstSampler(true),
        jaeger.NewRemoteReporter(sender),
    )
    return tracer, closer
}

Start a root span

Use this pattern at the entry point of an incoming request, where no parent span exists:

// Start a new root span for the operation.
span := tracer.StartSpan("myspan")
// Always call Finish() to flush the span to the reporter when the function returns.
defer span.Finish()

// Attach metadata to the span for filtering and analysis in the console.
clientSpan.SetTag("mytag", "123")

// Inject the trace context into outgoing HTTP headers
// so downstream services can continue the trace.
tracer.Inject(span.Context(), opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(req.Header))

Continue a trace from an incoming request

Use this pattern when handling a request from an already-instrumented upstream service:

// Extract the trace context from the incoming HTTP or RPC request headers.
spanCtx, _ := tracer.Extract(opentracing.HTTPHeaders, opentracing.HTTPHeadersCarrier(r.Header))

// Create a child span linked to the extracted parent context.
span := tracer.StartSpan("myspan", opentracing.ChildOf(spanCtx))
defer span.Finish()

For the full API reference, see Jaeger Bindings for Go OpenTracing API.