couchbase/dist/oteltracer.js

The official Couchbase Node.js Client Library.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getOTelTracer = exports.OTelWrapperTracer = exports.OTelWrapperSpan = void 0;
const observabilitytypes_1 = require("./observabilitytypes");
const version_1 = require("./version");
/* eslint-enable n/no-missing-import */
// Dynamic Runtime Require (Bundler-safe)
let otelApi = null;
let HAS_OTEL = false;
try {
    // Hiding the string prevents Webpack/Vite from throwing missing dependency errors
    const moduleName = '@opentelemetry/api';
    // eslint-disable-next-line @typescript-eslint/no-require-imports
    otelApi = require(moduleName);
    HAS_OTEL = true;
}
catch (_err) {
    HAS_OTEL = false;
}
/**
 * Wrapper class for OpenTelemetry Span that implements RequestSpan interface.
 */
class OTelWrapperSpan {
    /**
     * Creates an instance of OTelWrapperSpan.
     *
     * @param otelSpan - OpenTelemetry Span to wrap.
     * @param name - The name of the span.
     */
    constructor(otelSpan, name) {
        this._otelSpan = otelSpan;
        this.name = name;
    }
    /**
     * Sets an attribute on the span.
     *
     * @param key - The attribute key.
     * @param value - The attribute value.
     */
    setAttribute(key, value) {
        this._otelSpan.setAttribute(key, value);
    }
    /**
     * Adds an event to the span.
     *
     * @param key - The event key.
     * @param startTime - Optional timestamp for the event.
     */
    addEvent(key, startTime) {
        this._otelSpan.addEvent(key, startTime);
    }
    /**
     * Sets the status of the span.
     *
     * @param status - The SpanStatus to set.
     */
    setStatus(status) {
        // We use the non-null assertion (!) because this class cannot be
        // instantiated unless otelApi successfully loaded.
        let otelCode = otelApi.SpanStatusCode.UNSET;
        if (status.code === observabilitytypes_1.SpanStatusCode.OK) {
            otelCode = otelApi.SpanStatusCode.OK;
        }
        else if (status.code === observabilitytypes_1.SpanStatusCode.ERROR) {
            otelCode = otelApi.SpanStatusCode.ERROR;
        }
        this._otelSpan.setStatus({
            code: otelCode,
            message: status.message,
        });
    }
    /**
     * Ends the span.
     *
     * @param endTime - Optional timestamp for when the span ended.
     */
    end(endTime) {
        this._otelSpan.end(endTime);
    }
}
exports.OTelWrapperSpan = OTelWrapperSpan;
/**
 * Wrapper class for OpenTelemetry Tracer that implements RequestTracer interface.
 */
class OTelWrapperTracer {
    /**
     * Creates an instance of OTelWrapperTracer.
     *
     * @param tracer - OpenTelemetry Tracer to wrap.
     */
    constructor(tracer) {
        this._tracer = tracer;
    }
    /**
     * Creates a new request span, optionally with a parent span.
     *
     * @param name - The name of the span.
     * @param parentSpan - Optional parent span for this request.
     * @param startTime - Optional timestamp for when the span started.
     * @returns A RequestSpan instance for the new span.
     */
    requestSpan(name, parentSpan, startTime) {
        // Grab the current active context from OTel
        let context = otelApi.context.active();
        // If the user passed in a parent span, and it is one of our wrappers,
        // extract the raw OTel span and inject it into a new context.
        if (parentSpan && parentSpan instanceof OTelWrapperSpan) {
            context = otelApi.trace.setSpan(context, parentSpan._otelSpan);
        }
        // Start the new span using the safely mapped inputs
        const span = this._tracer.startSpan(name, {
            startTime: startTime,
            kind: otelApi.SpanKind.CLIENT,
        }, context);
        return new OTelWrapperSpan(span, name);
    }
}
exports.OTelWrapperTracer = OTelWrapperTracer;
/**
 * Creates an OpenTelemetry wrapper tracer.
 * Throws an Error if @opentelemetry/api is not installed.
 */
function getOTelTracer(tracerProvider) {
    if (!HAS_OTEL || !otelApi) {
        throw new Error('OpenTelemetry is not installed. Please install it with: ' +
            'npm install @opentelemetry/api');
    }
    const pkgName = `com.couchbase.client/nodejs`;
    const pkgVersion = version_1.SDK_VERSION;
    let tracer;
    if (tracerProvider) {
        // Use the explicit provider they passed in
        tracer = tracerProvider.getTracer(pkgName, pkgVersion);
    }
    else {
        // Fallback to the global OpenTelemetry provider
        tracer = otelApi.trace.getTracer(pkgName, pkgVersion);
    }
    return new OTelWrapperTracer(tracer);
}
exports.getOTelTracer = getOTelTracer;