@upstash/context7-mcp/dist/lib/telemetry-runtime.js

MCP server for Context7

import { embeddedPrometheusIsEnabled, telemetryIsDisabled } from "./telemetry-config.js";
const TELEMETRY_DISABLED = telemetryIsDisabled();
let implementation;
let implementationPromise;
let mcpImplementationPromise;
let prometheusStartup;
function loadImplementation() {
    implementationPromise ??= import("./telemetry.js")
        .then((loaded) => {
        implementation = loaded;
        return loaded;
    })
        .catch((error) => {
        implementationPromise = undefined;
        throw error;
    });
    return implementationPromise;
}
function loadMcpImplementation() {
    mcpImplementationPromise ??= import("./mcp-telemetry.js").catch((error) => {
        mcpImplementationPromise = undefined;
        throw error;
    });
    return mcpImplementationPromise;
}
async function startEmbeddedPrometheus(serviceVersion) {
    prometheusStartup ??= import("./telemetry-provider.js")
        .then(({ startPrometheusMetrics }) => startPrometheusMetrics(serviceVersion))
        .catch((error) => {
        prometheusStartup = undefined;
        throw error;
    });
    await prometheusStartup;
}
export async function initializeTelemetry(options) {
    if (TELEMETRY_DISABLED)
        return undefined;
    const [loadedTelemetry, loadedMcpTelemetry] = await Promise.all([
        loadImplementation(),
        loadMcpImplementation(),
    ]);
    implementation = loadedTelemetry;
    if (options.allowEmbeddedPrometheus && embeddedPrometheusIsEnabled()) {
        await startEmbeddedPrometheus(options.serviceVersion);
    }
    return {
        createServer: (serverInfo, serverOptions, requestContext) => new loadedMcpTelemetry.InstrumentedMcpServer(serverInfo, serverOptions, requestContext),
        instrumentHttpHandler: loadedMcpTelemetry.instrumentMcpHttpHandler,
        instrumentStdioTransport: loadedMcpTelemetry.instrumentStdioTransport,
    };
}
export async function observeAuthentication(options, operation) {
    if (TELEMETRY_DISABLED)
        return operation();
    return (await loadImplementation()).observeAuthentication(options, operation);
}
export function recordAuthenticationEvent(observation) {
    implementation?.recordAuthenticationEvent(observation);
}
export function recordSelfCancellingBatch(userAgent) {
    implementation?.recordSelfCancellingBatch(userAgent);
}
export async function observeUpstreamRequest(operationName, request, consumeResponse, options = {}) {
    if (TELEMETRY_DISABLED)
        return consumeResponse(await request());
    return (await loadImplementation()).observeUpstreamRequest(operationName, request, consumeResponse, options);
}
export function recordToolCallOutcome(outcome) {
    implementation?.recordToolCallOutcome(outcome);
}
export async function forceFlushTelemetry() {
    await implementation?.forceFlushTelemetry();
}