Distributed tracing

import Tracelit from "@tracelit/sdk";

const result = await Tracelit.tracer.startActiveSpan("process-payment", async (span) => {
  span.setAttribute("payment.id", payment.id);
  span.setAttribute("payment.currency", currency);

  try {
    return await processPayment(payment);
  } catch (err) {
    span.recordException(err as Error);
    span.setStatus({ code: 2, message: (err as Error).message });
    throw err;
  } finally {
    span.end();
  }
});

ctx, span := tracelit.StartSpan(ctx, "process-payment",
    tracelit.WithSpanAttributes(map[string]any{
        "payment.id":       payment.ID,
        "payment.currency": payment.Currency,
    }),
)
defer span.End()

if err := processPayment(ctx, payment); err != nil {
    span.RecordError(err)
    return err
}

Tracelit.tracer.in_span("process_payment") do |span|
  span.set_attribute("payment.id", payment.id.to_s)
  span.set_attribute("payment.currency", currency)

  process(payment)
end

using var span = TracelitClient.Tracer.StartActiveSpan("process-payment");
span?.SetTag("payment.id", payment.Id.ToString());
span?.SetTag("payment.currency", currency);

try
{
    return ProcessPayment(payment);
}
catch (Exception ex)
{
    span?.RecordException(ex);
    span?.SetStatus(Status.Error.WithDescription(ex.Message));
    throw;
}

import { propagation, context } from "@opentelemetry/api";

// Inject into message headers before publishing
const carrier: Record<string, string> = {};
propagation.inject(context.active(), carrier);
await queue.publish({ ...message, headers: carrier });

// Extract on the consumer side
const ctx = propagation.extract(context.active(), message.headers);
Tracelit.tracer.startActiveSpan("process-job", { context: ctx }, async (span) => {
  // ...
  span.end();
});

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

// Inject before publishing
carrier := propagation.MapCarrier{}
otel.GetTextMapPropagator().Inject(ctx, carrier)

// Extract on the consumer side
ctx = otel.GetTextMapPropagator().Extract(ctx, carrier)
ctx, span := tracelit.StartConsumerSpan(ctx, "process-job")
defer span.End()