@brizz/sdk 0.1.28 → 0.1.30

package/README.md

@@ -190,9 +190,22 @@ The SDK automatically instruments:
 - **LangChain** - `langchain` and `@langchain/*` packages
 - **LlamaIndex** - `llamaindex` package
 - **AWS Bedrock** - `@aws-sdk/client-bedrock-runtime`
-- **Google Vertex AI** - `@google-cloud/vertexai`
 - **Vector Databases** - Pinecone, Qdrant, ChromaDB
-- **HTTP/Fetch** - Automatic network request tracing
+
+### Optional Instrumentations
+
+A few instrumentations ship as **optional peer dependencies** so they're only
+pulled in when you need them. Install the matching package(s) to enable them:
+
+| To trace | Install |
+| --- | --- |
+| **Google Vertex AI** (`@google-cloud/vertexai`) | `npm install @traceloop/instrumentation-vertexai` |
+| **MCP** (Model Context Protocol) | `npm install @arizeai/openinference-instrumentation-mcp @modelcontextprotocol/sdk` |
+
+If a package isn't installed, the SDK keeps working and simply skips that
+instrumentation. On the automatic path the skip is a quiet `debug` log; when you
+opt in explicitly via `instrumentModules`, a missing package is logged at `error`
+so the misconfiguration is visible.
 
 ### Vercel AI SDK Integration
 
@@ -331,6 +344,20 @@ await startSession('session-456', async (session) => {
 });
 ```
 
+**External link example:**
+
+```typescript
+import { addExternalLink, startSession } from '@brizz/sdk';
+
+startSession('session-123', (session) => {
+  // Top-level function — resolves the active session from context.
+  addExternalLink('https://app.datadoghq.com/trace/abc', { title: 'Datadog trace' });
+});
+
+// Outside a session — pass the id explicitly.
+addExternalLink('https://sentry.io/issues/456', { sessionId: 'session-123', linkType: 'sentry' });
+```
+
 ### Session Title Generation
 
 If you use an LLM call to generate session titles, wrap it so those spans don't appear as part of

package/dist/chunk-3OLW4TOG.js

@@ -0,0 +1,158 @@
+// src/internal/logger.ts
+import { DiagLogLevel } from "@opentelemetry/api";
+import pino from "pino";
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["NONE"] = 0] = "NONE";
+  LogLevel2[LogLevel2["ERROR"] = 1] = "ERROR";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["INFO"] = 3] = "INFO";
+  LogLevel2[LogLevel2["DEBUG"] = 4] = "DEBUG";
+  return LogLevel2;
+})(LogLevel || {});
+var DEFAULT_LOG_LEVEL = 2 /* WARN */;
+var PinoLogger = class {
+  _level = DEFAULT_LOG_LEVEL;
+  _pinoLogger = null;
+  debug = (msg, ...meta) => {
+    if (this._level >= 4 /* DEBUG */) {
+      this.ensurePinoLogger().debug(this.formatMeta(meta), msg);
+    }
+  };
+  info = (msg, ...meta) => {
+    if (this._level >= 3 /* INFO */) {
+      this.ensurePinoLogger().info(this.formatMeta(meta), msg);
+    }
+  };
+  warn = (msg, ...meta) => {
+    if (this._level >= 2 /* WARN */) {
+      this.ensurePinoLogger().warn(this.formatMeta(meta), msg);
+    }
+  };
+  error = (msg, ...meta) => {
+    if (this._level >= 1 /* ERROR */) {
+      this.ensurePinoLogger().error(this.formatMeta(meta), msg);
+    }
+  };
+  constructor() {
+    const envLevel = this.getLogLevelFromEnv();
+    this._level = envLevel;
+  }
+  /**
+   * Lazy initialization of Pino logger to ensure it's created AFTER Jest spies
+   * are set up during tests. This prevents the pino-pretty transport from
+   * bypassing stdout/stderr spies.
+   */
+  ensurePinoLogger() {
+    if (!this._pinoLogger) {
+      this._pinoLogger = pino({
+        name: "Brizz",
+        level: this.logLevelToPino(this._level),
+        // Disable transport in test environment to allow proper spy capture
+        transport: this.isProduction() || this.isTest() ? void 0 : {
+          target: "pino-pretty",
+          options: {
+            singleLine: true,
+            colorize: true,
+            translateTime: "HH:MM:ss",
+            ignore: "pid,hostname",
+            messageFormat: "[{name}] {msg}"
+          }
+        }
+      });
+    }
+    return this._pinoLogger;
+  }
+  isProduction() {
+    return process.env["NODE_ENV"] === "production";
+  }
+  isTest() {
+    return process.env["NODE_ENV"] === "test";
+  }
+  getLogLevelFromEnv() {
+    const envLevel = process.env["BRIZZ_LOG_LEVEL"];
+    return envLevel ? parseLogLevel(envLevel) : DEFAULT_LOG_LEVEL;
+  }
+  logLevelToPino(level) {
+    switch (level) {
+      case 4 /* DEBUG */:
+        return "debug";
+      case 3 /* INFO */:
+        return "info";
+      case 2 /* WARN */:
+        return "warn";
+      case 1 /* ERROR */:
+        return "error";
+      default:
+        return "silent";
+    }
+  }
+  formatMeta(meta) {
+    if (meta.length === 0) {
+      return {};
+    }
+    if (meta.length === 1 && typeof meta[0] === "object" && meta[0] !== null) {
+      return meta[0];
+    }
+    return { metadata: meta };
+  }
+  setLevel(level) {
+    this._level = level;
+    if (this._pinoLogger) {
+      this._pinoLogger.level = this.logLevelToPino(level);
+    }
+  }
+  getLevel() {
+    return this._level;
+  }
+};
+function parseLogLevel(level) {
+  if (!level) {
+    return DEFAULT_LOG_LEVEL;
+  }
+  const normalizedLevel = level.toLowerCase().trim();
+  switch (normalizedLevel) {
+    case "debug":
+      return 4 /* DEBUG */;
+    case "info":
+      return 3 /* INFO */;
+    case "warn":
+    case "warning":
+      return 2 /* WARN */;
+    case "error":
+      return 1 /* ERROR */;
+    case "none":
+    case "off":
+    case "silent":
+      return 0 /* NONE */;
+    default: {
+      const numLevel = Math.trunc(Number(normalizedLevel));
+      if (!Number.isNaN(numLevel) && numLevel >= 0 && numLevel <= 4) {
+        return numLevel;
+      }
+      return DEFAULT_LOG_LEVEL;
+    }
+  }
+}
+var logger = new PinoLogger();
+function setLogLevel(level) {
+  const resolvedLevel = typeof level === "string" ? parseLogLevel(level) : level;
+  logger.setLevel(resolvedLevel);
+}
+function getLogLevel() {
+  return logger.getLevel();
+}
+
+// src/internal/version.ts
+function getSDKVersion() {
+  return "0.1.30";
+}
+
+export {
+  LogLevel,
+  DEFAULT_LOG_LEVEL,
+  parseLogLevel,
+  logger,
+  setLogLevel,
+  getLogLevel,
+  getSDKVersion
+};