@brizz/sdk 0.1.20 → 0.1.22

package/dist/preload.cjs

@@ -258,6 +258,618 @@ var import_instrumentation_pinecone = require("@traceloop/instrumentation-pineco
 var import_instrumentation_qdrant = require("@traceloop/instrumentation-qdrant");
 var import_instrumentation_together = require("@traceloop/instrumentation-together");
 var import_instrumentation_vertexai = require("@traceloop/instrumentation-vertexai");
+
+// src/internal/instrumentation/mcp/instrumentation.ts
+var import_openinference_instrumentation_mcp = require("@arizeai/openinference-instrumentation-mcp");
+var import_api6 = require("@opentelemetry/api");
+var import_instrumentation = require("@opentelemetry/instrumentation");
+
+// src/internal/instrumentation/mcp/patches/protocol.ts
+var import_api5 = require("@opentelemetry/api");
+
+// src/internal/instrumentation/mcp/session.ts
+var import_api3 = require("@opentelemetry/api");
+
+// src/internal/semantic-conventions.ts
+var import_api2 = require("@opentelemetry/api");
+var BRIZZ = "brizz";
+var PROPERTIES = "properties";
+var SESSION_ID = "session.id";
+var PROPERTIES_CONTEXT_KEY = (0, import_api2.createContextKey)(PROPERTIES);
+var SESSION_OBJECT_CONTEXT_KEY = (0, import_api2.createContextKey)("brizz.session.object");
+
+// src/internal/instrumentation/mcp/session.ts
+function stampAndPropagateSession(span, sessionId, baseContext = import_api3.context.active()) {
+  if (!sessionId) {
+    return { context: baseContext, sessionId: null };
+  }
+  if (span.isRecording()) {
+    try {
+      span.setAttribute(`${BRIZZ}.${SESSION_ID}`, sessionId);
+    } catch (error) {
+      logger.warn(
+        `Brizz MCP: failed to stamp session id on span: ${String(error)}`
+      );
+    }
+  }
+  try {
+    const prev = baseContext.getValue(PROPERTIES_CONTEXT_KEY);
+    const merged = prev ? { ...prev, [SESSION_ID]: sessionId } : { [SESSION_ID]: sessionId };
+    return {
+      context: baseContext.setValue(PROPERTIES_CONTEXT_KEY, merged),
+      sessionId
+    };
+  } catch (error) {
+    logger.warn(`Brizz MCP: failed to attach session context: ${String(error)}`);
+    return { context: baseContext, sessionId };
+  }
+}
+
+// src/internal/instrumentation/mcp/patches/attributes.ts
+var import_api4 = require("@opentelemetry/api");
+
+// src/internal/instrumentation/mcp/semantic-conventions.ts
+var MCP_TOOL_NAME = "mcp.tool.name";
+var MCP_TOOL_ARGUMENTS = "mcp.tool.arguments";
+var MCP_TOOL_RESULT = "mcp.tool.result";
+var MCP_COMPONENT_TYPE = "mcp.component.type";
+var MCP_COMPONENT_TOOL = "tool";
+var MCP_METHOD_NAME = "mcp.method.name";
+var MCP_REQUEST_ID = "mcp.request.id";
+var MCP_SESSION_ID = "mcp.session.id";
+var MCP_PROTOCOL_VERSION = "mcp.protocol.version";
+var MCP_RESOURCE_URI = "mcp.resource.uri";
+var RPC_SYSTEM = "rpc.system";
+var RPC_SYSTEM_MCP = "mcp";
+var RPC_RESPONSE_STATUS_CODE = "rpc.response.status_code";
+var GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+var GEN_AI_PROMPT_NAME = "gen_ai.prompt.name";
+var GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+var GEN_AI_OPERATION_EXECUTE_TOOL = "execute_tool";
+var NETWORK_TRANSPORT = "network.transport";
+var ERROR_TYPE = "error.type";
+var ERROR_TYPE_TOOL = "tool_error";
+var JSONRPC_REQUEST_ID = "jsonrpc.request.id";
+var SPAN_NAME_TOOLS_CALL = "tools/call";
+var MAX_ATTRIBUTE_LENGTH = 32 * 1024;
+var TRUNCATION_SUFFIX = "\u2026(truncated)";
+var METHOD_TOOLS_CALL = "tools/call";
+var METHOD_RESOURCES_READ = "resources/read";
+var METHOD_PROMPTS_GET = "prompts/get";
+var METHOD_INITIALIZE = "initialize";
+
+// src/internal/instrumentation/mcp/patches/attributes.ts
+function deriveSpanName(method, params) {
+  try {
+    if (method === METHOD_TOOLS_CALL) {
+      const name = typeof params?.["name"] === "string" ? params["name"] : "";
+      return name ? `${SPAN_NAME_TOOLS_CALL} ${name}` : SPAN_NAME_TOOLS_CALL;
+    }
+    if (method === METHOD_RESOURCES_READ) {
+      const uri = typeof params?.["uri"] === "string" ? params["uri"] : "";
+      return uri ? `${METHOD_RESOURCES_READ} ${uri}` : METHOD_RESOURCES_READ;
+    }
+    if (method === METHOD_PROMPTS_GET) {
+      const name = typeof params?.["name"] === "string" ? params["name"] : "";
+      return name ? `${METHOD_PROMPTS_GET} ${name}` : METHOD_PROMPTS_GET;
+    }
+    return method;
+  } catch {
+    return method || "mcp";
+  }
+}
+function applyBaseAttributes(span, request) {
+  span.setAttribute(RPC_SYSTEM, RPC_SYSTEM_MCP);
+  if (request.method) {
+    span.setAttribute(MCP_METHOD_NAME, request.method);
+  }
+  if (request.id !== void 0 && request.id !== null) {
+    const id = String(request.id);
+    span.setAttribute(MCP_REQUEST_ID, id);
+    span.setAttribute(JSONRPC_REQUEST_ID, id);
+  }
+}
+function applyClientRequestAttributes(span, request, transportName) {
+  applyBaseAttributes(span, request);
+  applyMethodSpecificRequestAttributes(span, request);
+  if (transportName) {
+    const transport = normalizeTransport(transportName);
+    if (transport) {
+      span.setAttribute(NETWORK_TRANSPORT, transport);
+    }
+  }
+}
+function applyServerRequestAttributes(span, request, protocol) {
+  applyBaseAttributes(span, request);
+  applyMethodSpecificRequestAttributes(span, request);
+  if (request.method === METHOD_TOOLS_CALL) {
+    const args = request.params?.["arguments"];
+    if (args !== void 0) {
+      span.setAttribute(MCP_TOOL_ARGUMENTS, serializeForAttribute(args));
+    }
+  }
+  const sessionId = protocol.sessionId ?? protocol._transport?.sessionId;
+  if (sessionId) {
+    span.setAttribute(MCP_SESSION_ID, String(sessionId));
+  }
+}
+function applyMethodSpecificRequestAttributes(span, request) {
+  const params = request.params ?? {};
+  switch (request.method) {
+    case METHOD_TOOLS_CALL: {
+      const name = typeof params["name"] === "string" ? params["name"] : "";
+      if (name) {
+        span.setAttribute(MCP_TOOL_NAME, name);
+        span.setAttribute(GEN_AI_TOOL_NAME, name);
+      }
+      span.setAttribute(MCP_COMPONENT_TYPE, MCP_COMPONENT_TOOL);
+      span.setAttribute(GEN_AI_OPERATION_NAME, GEN_AI_OPERATION_EXECUTE_TOOL);
+      break;
+    }
+    case METHOD_RESOURCES_READ: {
+      const uri = typeof params["uri"] === "string" ? params["uri"] : "";
+      if (uri) {
+        span.setAttribute(MCP_RESOURCE_URI, uri);
+      }
+      break;
+    }
+    case METHOD_PROMPTS_GET: {
+      const name = typeof params["name"] === "string" ? params["name"] : "";
+      if (name) {
+        span.setAttribute(GEN_AI_PROMPT_NAME, name);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+function applyResultAttributes(span, method, result) {
+  if (method === METHOD_INITIALIZE && result && typeof result === "object") {
+    const protocolVersion = result["protocolVersion"];
+    if (typeof protocolVersion === "string") {
+      span.setAttribute(MCP_PROTOCOL_VERSION, protocolVersion);
+    }
+    return;
+  }
+  if (method !== METHOD_TOOLS_CALL) {
+    return;
+  }
+  const obj = result && typeof result === "object" ? result : null;
+  const content = obj?.["content"] ?? result;
+  span.setAttribute(MCP_TOOL_RESULT, serializeForAttribute(content));
+  if (obj && obj["isError"] === true) {
+    span.setAttribute(ERROR_TYPE, ERROR_TYPE_TOOL);
+    const message = extractToolErrorMessage(obj);
+    span.setStatus({ code: import_api4.SpanStatusCode.ERROR, message });
+  }
+}
+function applyErrorAttributes(span, err) {
+  const error = err;
+  const code = error?.code;
+  if (typeof code === "number") {
+    span.setAttribute(RPC_RESPONSE_STATUS_CODE, code);
+    span.setAttribute(ERROR_TYPE, String(code));
+  } else if (error?.name === "AbortError") {
+    span.setAttribute(ERROR_TYPE, "cancelled");
+  } else if (error?.name === "TimeoutError") {
+    span.setAttribute(ERROR_TYPE, "timeout");
+  } else {
+    span.setAttribute(
+      ERROR_TYPE,
+      error?.constructor?.name || error?.name || "Error"
+    );
+  }
+  try {
+    span.recordException(error);
+  } catch {
+  }
+  span.setStatus({
+    code: import_api4.SpanStatusCode.ERROR,
+    message: typeof error?.message === "string" ? error.message : void 0
+  });
+}
+function serializeForAttribute(value) {
+  const raw = rawSerialize(value);
+  if (raw.length <= MAX_ATTRIBUTE_LENGTH) {
+    return raw;
+  }
+  return raw.slice(0, MAX_ATTRIBUTE_LENGTH - TRUNCATION_SUFFIX.length) + TRUNCATION_SUFFIX;
+}
+function rawSerialize(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    try {
+      if (value === null || value === void 0) {
+        return "";
+      }
+      const tag = Object.prototype.toString.call(value);
+      return typeof value.toString === "function" ? (
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        String(value)
+      ) : tag;
+    } catch {
+      return "";
+    }
+  }
+}
+function extractToolErrorMessage(result) {
+  const content = result["content"];
+  if (Array.isArray(content)) {
+    for (const item of content) {
+      if (item && typeof item === "object") {
+        const text = item["text"];
+        if (typeof text === "string") {
+          return text;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function normalizeTransport(ctorName) {
+  const name = ctorName.toLowerCase();
+  if (name.includes("stdio")) {
+    return "stdio";
+  }
+  if (name.includes("sse")) {
+    return "sse";
+  }
+  if (name.includes("streamablehttp") || name.includes("http")) {
+    return "http";
+  }
+  return null;
+}
+
+// src/internal/instrumentation/mcp/patches/protocol.ts
+var PATCHED_FLAG = /* @__PURE__ */ Symbol("brizz.mcp.protocol-patched");
+function patchProtocolPrototype(prototype, tracer) {
+  if (!prototype || typeof prototype !== "object") {
+    return false;
+  }
+  const proto = prototype;
+  if (proto[PATCHED_FLAG]) {
+    logger.debug("Brizz MCP: Protocol.prototype already patched, skipping");
+    return false;
+  }
+  const originalRequest = proto["request"];
+  const originalOnRequest = proto["_onrequest"];
+  if (typeof originalRequest === "function") {
+    proto["request"] = wrapRequest(originalRequest, tracer);
+  } else {
+    logger.debug(
+      "Brizz MCP: Protocol.prototype.request missing \u2014 skipping CLIENT patch"
+    );
+  }
+  if (typeof originalOnRequest === "function") {
+    proto["_onrequest"] = wrapOnRequest(
+      originalOnRequest,
+      tracer
+    );
+  } else {
+    logger.debug(
+      "Brizz MCP: Protocol.prototype._onrequest missing \u2014 skipping SERVER patch"
+    );
+  }
+  proto[PATCHED_FLAG] = true;
+  return true;
+}
+function wrapRequest(original, tracer) {
+  return function wrappedRequest(...args) {
+    const request = args[0];
+    if (!request || typeof request !== "object" || !request.method) {
+      return original.apply(this, args);
+    }
+    const span = safeStartClientSpan(tracer, request, this);
+    if (!span) {
+      return original.apply(this, args);
+    }
+    return executeAroundSpan(span, request.method, () => {
+      const ctx = import_api5.trace.setSpan(import_api5.context.active(), span);
+      return import_api5.context.with(ctx, () => original.apply(this, args));
+    });
+  };
+}
+function wrapOnRequest(original, tracer) {
+  return function wrappedOnRequest(...args) {
+    const request = args[0];
+    if (!request || typeof request !== "object" || !request.method) {
+      return original.apply(this, args);
+    }
+    const handlers = this._requestHandlers;
+    if (!handlers || typeof handlers.get !== "function") {
+      return original.apply(this, args);
+    }
+    const method = request.method;
+    const handler = handlers.get(method) ?? this.fallbackRequestHandler;
+    if (!handler) {
+      return original.apply(this, args);
+    }
+    const started = safeStartServerSpan(tracer, request, this);
+    if (!started) {
+      return original.apply(this, args);
+    }
+    const { span, spanCtx } = started;
+    const wrappedHandler = (req, extra) => import_api5.context.with(spanCtx, () => executeHandler(span, method, handler, req, extra));
+    const hadEntry = handlers.has(method);
+    const prev = handlers.get(method);
+    handlers.set(method, wrappedHandler);
+    const usedFallback = !hadEntry && this.fallbackRequestHandler === handler;
+    const fallbackPrev = usedFallback ? this.fallbackRequestHandler : void 0;
+    if (usedFallback) {
+      this.fallbackRequestHandler = wrappedHandler;
+    }
+    try {
+      return original.apply(this, args);
+    } finally {
+      if (hadEntry) {
+        handlers.set(method, prev);
+      } else {
+        handlers.delete(method);
+      }
+      if (usedFallback) {
+        this.fallbackRequestHandler = fallbackPrev;
+      }
+    }
+  };
+}
+function executeAroundSpan(span, method, run) {
+  let result;
+  try {
+    result = run();
+  } catch (error) {
+    safeApplyErrorAttributes(span, error);
+    safeEnd(span);
+    throw error;
+  }
+  if (!isThenable(result)) {
+    safeApplyResultAttributes(span, method, result);
+    safeEnd(span);
+    return result;
+  }
+  return result.then(
+    (value) => {
+      safeApplyResultAttributes(span, method, value);
+      safeEnd(span);
+      return value;
+    },
+    (error) => {
+      safeApplyErrorAttributes(span, error);
+      safeEnd(span);
+      throw error;
+    }
+  );
+}
+function executeHandler(span, method, handler, req, extra) {
+  return executeAroundSpan(span, method, () => handler(req, extra));
+}
+function safeStartClientSpan(tracer, request, protocol) {
+  try {
+    const spanName = deriveSpanName(request.method, request.params);
+    const span = tracer.startSpan(spanName, { kind: import_api5.SpanKind.CLIENT });
+    applyClientRequestAttributes(
+      span,
+      request,
+      protocol._transport?.constructor?.name
+    );
+    return span;
+  } catch (error) {
+    logger.debug(`Brizz MCP: failed to open CLIENT span: ${String(error)}`);
+    return null;
+  }
+}
+function safeStartServerSpan(tracer, request, protocol) {
+  try {
+    const parentCtx = extractParentContext(request);
+    const spanName = deriveSpanName(request.method, request.params);
+    const span = tracer.startSpan(
+      spanName,
+      { kind: import_api5.SpanKind.SERVER },
+      parentCtx
+    );
+    applyServerRequestAttributes(span, request, protocol);
+    const sessionId = protocol.sessionId ?? protocol._transport?.sessionId;
+    const { context: sessCtx } = stampAndPropagateSession(span, sessionId, parentCtx);
+    return { span, spanCtx: import_api5.trace.setSpan(sessCtx, span) };
+  } catch (error) {
+    logger.debug(`Brizz MCP: failed to open SERVER span: ${String(error)}`);
+    return null;
+  }
+}
+function extractParentContext(request) {
+  try {
+    const meta = request.params?._meta;
+    if (meta && typeof meta === "object") {
+      return import_api5.propagation.extract(import_api5.context.active(), meta);
+    }
+  } catch (error) {
+    logger.debug(
+      `Brizz MCP: failed to extract parent context from _meta: ${String(error)}`
+    );
+  }
+  return import_api5.context.active();
+}
+function isThenable(value) {
+  return !!value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
+}
+function safeApplyResultAttributes(span, method, value) {
+  try {
+    applyResultAttributes(span, method, value);
+  } catch (error) {
+    logger.debug(
+      `Brizz MCP: failed to apply result attributes: ${String(error)}`
+    );
+  }
+}
+function safeApplyErrorAttributes(span, err) {
+  try {
+    applyErrorAttributes(span, err);
+  } catch (error) {
+    logger.debug(
+      `Brizz MCP: failed to apply error attributes: ${String(error)}`
+    );
+  }
+}
+function safeEnd(span) {
+  try {
+    span.end();
+  } catch (error) {
+    logger.debug(`Brizz MCP: failed to end span: ${String(error)}`);
+  }
+}
+
+// src/internal/version.ts
+function getSDKVersion() {
+  return "0.1.22";
+}
+
+// src/internal/instrumentation/mcp/version.ts
+var INSTRUMENTATION_NAME = "@brizz/sdk/mcp";
+var INSTRUMENTATION_VERSION = getSDKVersion();
+
+// src/internal/instrumentation/mcp/instrumentation.ts
+var PROTOCOL_MODULE_NAME = "@modelcontextprotocol/sdk/shared/protocol.js";
+var PROTOCOL_SUPPORTED_VERSIONS = [">=1.0.0 <2"];
+var MCPInstrumentation = class extends import_openinference_instrumentation_mcp.MCPInstrumentation {
+  /**
+   * Dedicated Brizz-named tracer for our SERVER + CLIENT spans.
+   *
+   * Why a separate tracer from the parent class's one: Arize's inherited
+   * transport patches don't emit spans (they only inject propagation
+   * headers), so using our own tracer here keeps Brizz spans attributed to
+   * `@brizz/sdk/mcp` in the dashboard. The parent's `tracer` is a
+   * `protected get` (no setter), so fighting it with assignment is the
+   * wrong tool.
+   */
+  brizzTracer;
+  constructor(_config) {
+    super({ instrumentationConfig: _config?.instrumentationConfig });
+    this.brizzTracer = import_api6.trace.getTracer(INSTRUMENTATION_NAME, INSTRUMENTATION_VERSION);
+  }
+  /**
+   * Extend `super.init()` with our protocol-layer module definition.
+   *
+   * Arize's `init()` returns definitions for the six transport modules
+   * (SSE client/server, stdio client/server, streamable-HTTP client/server)
+   * whose `send`/`start` methods get patched for W3C trace-context
+   * injection. We append one more: `@modelcontextprotocol/sdk/shared/protocol.js`
+   * where our patches open SERVER/CLIENT spans around the handler + outgoing
+   * request. If `super.init()` throws (unlikely but possible across Arize
+   * versions), we gracefully degrade to protocol-only instrumentation.
+   *
+   * The cast at the end satisfies the parent's strongly-typed generic
+   * without leaking the cast into call sites.
+   */
+  init() {
+    let base;
+    try {
+      base = super.init() ?? [];
+    } catch (error) {
+      logger.warn(
+        `Brizz MCP: base Arize init() failed \u2014 transport context propagation disabled: ${String(error)}`
+      );
+      base = [];
+    }
+    const baseArr = Array.isArray(base) ? base : [base];
+    const brizzDef = new import_instrumentation.InstrumentationNodeModuleDefinition(
+      PROTOCOL_MODULE_NAME,
+      PROTOCOL_SUPPORTED_VERSIONS,
+      (module3) => {
+        this.patchProtocolModule(module3);
+        return module3;
+      },
+      (module3) => {
+        this.unpatchProtocolModule(module3);
+        return module3;
+      }
+    );
+    return [...baseArr, brizzDef];
+  }
+  /**
+   * Manually instrument MCP modules for Next.js/Webpack where the
+   * auto-instrumentation module-load hook doesn't fire.
+   *
+   * Forwards the six transport module fields to the inherited Arize
+   * `manuallyInstrument(...)` (context propagation) and applies our
+   * protocol patch if `protocolModule` is provided (SERVER/CLIENT spans).
+   * Both legs are try/catch-guarded — a failure in one shouldn't prevent
+   * the other from taking effect.
+   */
+  manuallyInstrument(modules) {
+    const {
+      clientSSEModule,
+      serverSSEModule,
+      clientStdioModule,
+      serverStdioModule,
+      clientStreamableHTTPModule,
+      serverStreamableHTTPModule,
+      protocolModule
+    } = modules;
+    try {
+      super.manuallyInstrument({
+        clientSSEModule,
+        serverSSEModule,
+        clientStdioModule,
+        serverStdioModule,
+        clientStreamableHTTPModule,
+        serverStreamableHTTPModule
+      });
+    } catch (error) {
+      logger.warn(`Brizz MCP: Arize manuallyInstrument(...) failed: ${String(error)}`);
+    }
+    if (protocolModule) {
+      try {
+        this.patchProtocolModule(protocolModule);
+      } catch (error) {
+        logger.warn(
+          `Brizz MCP: failed to manually patch Protocol module: ${String(error)}`
+        );
+      }
+    }
+  }
+  /**
+   * Apply the SERVER + CLIENT patch to a loaded `protocol.js` module. Shared
+   * by both the automatic module-load callback in `init()` and the manual
+   * `manuallyInstrument(...)` path above so there's exactly one place that
+   * calls `patchProtocolPrototype`.
+   */
+  patchProtocolModule(module3) {
+    const proto = module3?.Protocol?.prototype;
+    if (!proto) {
+      logger.debug(
+        "Brizz MCP: module does not expose Protocol.prototype \u2014 skipping protocol patches"
+      );
+      return;
+    }
+    const ok = patchProtocolPrototype(proto, this.brizzTracer);
+    if (ok) {
+      logger.debug("Brizz MCP: patched Protocol.prototype for SERVER+CLIENT spans");
+    }
+  }
+  /**
+   * Unpatch is intentionally a no-op.
+   *
+   * `patchProtocolPrototype` wraps methods in place and sets a PATCHED_FLAG
+   * Symbol on the prototype to prevent double-patching. Restoring the
+   * originals would require us to hold references across module unloads,
+   * which isn't a pattern we need — instrumentation rarely gets torn down
+   * at runtime, and a process reload is the canonical way to detach.
+   */
+  unpatchProtocolModule(_module) {
+    logger.debug(
+      "Brizz MCP: unpatch is a no-op \u2014 reload the process to cleanly detach"
+    );
+  }
+};
+
+// src/internal/instrumentation/registry.ts
 var InstrumentationRegistry = class _InstrumentationRegistry {
   static instance;
   manualModules = null;
@@ -362,6 +974,14 @@ var InstrumentationRegistry = class _InstrumentationRegistry {
         }
       })();
     }
+    if (this.manualModules?.mcp) {
+      try {
+        new MCPInstrumentation({ exceptionLogger }).manuallyInstrument(this.manualModules.mcp);
+        logger.debug("Manual instrumentation enabled for MCP");
+      } catch (error) {
+        logger.error(`Failed to apply MCP instrumentation: ${String(error)}`);
+      }
+    }
   }
 };
 
@@ -371,13 +991,8 @@ var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-
 var import_resources = require("@opentelemetry/resources");
 var import_sdk_logs2 = require("@opentelemetry/sdk-logs");
 
-// src/internal/version.ts
-function getSDKVersion() {
-  return "0.1.20";
-}
-
 // src/internal/log/processors/log-processor.ts
-var import_api3 = require("@opentelemetry/api");
+var import_api7 = require("@opentelemetry/api");
 var import_sdk_logs = require("@opentelemetry/sdk-logs");
 
 // src/internal/masking/patterns.ts
@@ -1004,13 +1619,6 @@ function maskAttributes(attributes, rules, outputOriginalValue = false) {
   return maskedAttributes;
 }
 
-// src/internal/semantic-conventions.ts
-var import_api2 = require("@opentelemetry/api");
-var BRIZZ = "brizz";
-var PROPERTIES = "properties";
-var PROPERTIES_CONTEXT_KEY = (0, import_api2.createContextKey)(PROPERTIES);
-var SESSION_OBJECT_CONTEXT_KEY = (0, import_api2.createContextKey)("brizz.session.object");
-
 // src/internal/log/processors/log-processor.ts
 var DEFAULT_LOG_MASKING_RULES = [
   {
@@ -1030,7 +1638,7 @@ var BrizzSimpleLogRecordProcessor = class extends import_sdk_logs.SimpleLogRecor
     if (maskingConfig) {
       maskLog(logRecord, maskingConfig);
     }
-    const associationProperties = import_api3.context.active().getValue(PROPERTIES_CONTEXT_KEY);
+    const associationProperties = import_api7.context.active().getValue(PROPERTIES_CONTEXT_KEY);
     if (associationProperties) {
       for (const [key, value] of Object.entries(associationProperties)) {
         logRecord.setAttribute(`${BRIZZ}.${key}`, value);
@@ -1050,7 +1658,7 @@ var BrizzBatchLogRecordProcessor = class extends import_sdk_logs.BatchLogRecordP
     if (maskingConfig) {
       maskLog(logRecord, maskingConfig);
     }
-    const associationProperties = import_api3.context.active().getValue(PROPERTIES_CONTEXT_KEY);
+    const associationProperties = import_api7.context.active().getValue(PROPERTIES_CONTEXT_KEY);
     if (associationProperties) {
       for (const [key, value] of Object.entries(associationProperties)) {
         logRecord.setAttribute(`${BRIZZ}.${key}`, value);
@@ -1437,10 +2045,10 @@ var BrizzSpanExporter = class {
 };
 
 // src/internal/trace/processors/span-processor.ts
-var import_api4 = require("@opentelemetry/api");
+var import_api8 = require("@opentelemetry/api");
 var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
 function applyContextAttributes(span) {
-  const sessionProperties = import_api4.context.active().getValue(PROPERTIES_CONTEXT_KEY);
+  const sessionProperties = import_api8.context.active().getValue(PROPERTIES_CONTEXT_KEY);
   if (sessionProperties) {
     for (const [key, value] of Object.entries(sessionProperties)) {
       span.setAttribute(`${BRIZZ}.${key}`, value);
@@ -1637,7 +2245,7 @@ function getSpanProcessor() {
 }
 
 // src/internal/trace/session.ts
-var import_api5 = require("@opentelemetry/api");
+var import_api9 = require("@opentelemetry/api");
 
 // src/internal/sdk.ts
 var _Brizz = class __Brizz {