Request Tracing

  • how-to
    Collecting information about an individual request and its response is an essential feature of every observability stack.

    To give insight into a request/response flow, the SDK provides a RequestTracer interface and ships with both a default implementation as well as modules that can be plugged into feed the traces to external systems (including OpenTelemetry).

    The Default ThresholdLoggingTracer

    By default, the SDK will emit information about requests that are over a configurable threshold every 10 seconds. Note that if no requests are over the threshold no event / log will be emitted.

    It is possible to customize this behavior by modifying the configuration:

    ThresholdLoggingTracerConfig.Builder config = ThresholdLoggingTracerConfig.builder()
    CoreEnvironment environment = CoreEnvironment.builder().thresholdLoggingTracerConfig(config).build();

    In this case the emit interval is one minute and Key/Value requests will only be considered if their latency is greater or equal than two seconds.

    The JSON blob emitted looks similar to the following (prettified here for readability):


    For each service (e.g. Key/Value or Query) an entry exists in the outer JSON array. The top N (10 by default) slowest operations are collected and displayed, sorted by the total duration. This promotes quick visibility of the "worst offenders" and more efficient troubleshooting.

    Please note that in future releases this format is planned to change for easier readability, so we do not provide any stability guarantees on the logging output format and it might change between minor versions.

    A new, yet to be stabilized, format can be enabled by setting the com.couchbase.thresholdRequestTracerNewOutputFormat system property to true. More information will be provided as we get closer to stabilization.

    OpenTelemetry Integration

    The built-in tracer is great if you do not have a centralized monitoring system, but if you already plug into the OpenTelemetry ecosystem we want to make sure to provide first-class support.

    The first thing you need to do is include an andditional dependency which provides the interoperability code:


    You also need to include your downstream exporter of choice, in the following example we’ll use Jaeger tracing:


    Next up, initialize the jaeger tracer:

    // Create a channel towards Jaeger end point
    ManagedChannel jaegerChannel = ManagedChannelBuilder.forAddress("localhost", 14250).usePlaintext().build();
    // Export traces to Jaeger
    JaegerGrpcSpanExporter jaegerExporter = JaegerGrpcSpanExporter.builder().setServiceName("otel-jaeger-example")
    // Set to process the spans by the Jaeger Exporter

    Once the exporter is set up, it can be wrapped into the OpenTelemetryRequestTracer and passed into the environment.

    // Wrap Tracer
    RequestTracer tracer = OpenTelemetryRequestTracer.wrap(OpenTelemetry.get());
    ClusterEnvironment environment = ClusterEnvironment.builder().requestTracer(tracer).build();

    At this point, all traces will be sent into the OpenTelemetry exporter. If you want to set a parent for a SDK request, you can do it in the respective *Options:

    GetResult result = collection.get(

    OpenTracing Integration

    In addition to OpenTelemetry, we also provide support for OpenTracing for legacy systems which have not yet migrated to OpenTelemetry. Note that we still recommend to migrate eventually since OpenTracing has been sunsetted.

    You need to include the tracing-opentracing module:


    And then wrap the Tracer:

    ClusterEnvironment environment = ClusterEnvironment