@brizz/sdk 0.1.16 → 0.1.18

package/README.md

@@ -20,6 +20,7 @@ libraries including OpenAI, Anthropic, Vercel AI SDK, and more.
 - [Session Tracking](#session-tracking)
 - [Custom Events & Logging](#custom-events--logging)
 - [Environment Variables](#environment-variables)
+- [Disable Span Export](#disable-span-export)
 - [Advanced Configuration](#advanced-configuration)
 - [Testing & Development](#testing--development)
 - [Package.json Examples](#packagejson-examples)
@@ -507,13 +508,26 @@ BRIZZ_BASE_URL=https://telemetry.brizz.dev    # Default telemetry endpoint
 BRIZZ_APP_NAME=my-app                         # Application name
 BRIZZ_APP_VERSION=1.0.0                       # Application version
 BRIZZ_ENVIRONMENT=production                  # Environment (dev, staging, prod)
-BRIZZ_LOG_LEVEL=info                         # SDK log level
+BRIZZ_LOG_LEVEL=info                          # SDK log level
+BRIZZ_DISABLE_SPAN_EXPORTER=true              # Skip span export (see "Disable Span Export")
 
 # OpenTelemetry Standard Variables
 OTEL_SERVICE_NAME=my-service                               # Service name
 OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true    # Capture AI content
 ```
 
+## Disable Span Export
+
+Keep `Brizz.initialize()` in your code without sending any spans — useful for dev/test
+environments. When enabled, the SDK skips span exporter and processor setup, so no
+spans are exported. Metrics and logs continue to work.
+
+```typescript
+Brizz.initialize({ apiKey: 'your-api-key', disableSpanExporter: true });
+```
+
+Or via env var: `BRIZZ_DISABLE_SPAN_EXPORTER=true`.
+
 ## Advanced Configuration
 
 ```typescript

package/dist/index.cjs

@@ -223,7 +223,14 @@ var exceptionLogger = (error) => {
 };
 function loadNodeAutoInstrumentations() {
   try {
-    const nodeInstrumentations = (0, import_auto_instrumentations_node.getNodeAutoInstrumentations)();
+    const nodeInstrumentations = (0, import_auto_instrumentations_node.getNodeAutoInstrumentations)({
+      // Disabled because @traceloop/instrumentation-openai wraps the same OpenAI
+      // prototype with richer span attributes (gen_ai.input.messages /
+      // gen_ai.output.messages). Leaving both enabled lets the official one win
+      // and route content to log events instead of span attributes, leaving the
+      // Brizz backend parser with no payload to read.
+      "@opentelemetry/instrumentation-openai": { enabled: false }
+    });
     (0, import_instrumentation.registerInstrumentations)({ instrumentations: nodeInstrumentations });
     return nodeInstrumentations;
   } catch (error) {
@@ -327,10 +334,12 @@ function resolveConfig(options) {
   const resolvedConfig = {
     ...options,
     appName: process.env["BRIZZ_APP_NAME"] || options.appName || "unknown-app",
+    appVersion: process.env["BRIZZ_APP_VERSION"] || options.appVersion,
     baseUrl: process.env["BRIZZ_BASE_URL"] || options.baseUrl || "https://telemetry.brizz.dev",
     headers: { ...options.headers },
     apiKey: process.env["BRIZZ_API_KEY"] || options.apiKey,
     disableBatch: process.env["BRIZZ_DISABLE_BATCH"] === "true" || !!options.disableBatch,
+    disableSpanExporter: process.env["BRIZZ_DISABLE_SPAN_EXPORTER"] === "true" || !!options.disableSpanExporter,
     environment: process.env["BRIZZ_ENVIRONMENT"] || options.environment,
     logLevel: resolvedLogLevel,
     masking: resolvedMasking
@@ -496,7 +505,7 @@ var import_sdk_logs2 = require("@opentelemetry/sdk-logs");
 
 // src/internal/version.ts
 function getSDKVersion() {
-  return "0.1.16";
+  return "0.1.18";
 }
 
 // src/internal/log/processors/log-processor.ts
@@ -1305,6 +1314,7 @@ var LoggingModule = class _LoggingModule {
       serviceName: config.appName
     });
     const resourceAttributes = {
+      ...config.resourceAttributes,
       "service.name": config.appName,
       [BRIZZ_SDK_VERSION]: getSDKVersion(),
       [BRIZZ_SDK_LANGUAGE]: SDK_LANGUAGE
@@ -1312,6 +1322,9 @@ var LoggingModule = class _LoggingModule {
     if (config.environment) {
       resourceAttributes["deployment.environment"] = config.environment;
     }
+    if (config.appVersion) {
+      resourceAttributes["service.version"] = config.appVersion;
+    }
     const resource = (0, import_resources.resourceFromAttributes)(resourceAttributes);
     logger.debug("Creating logger provider with resource");
     this.loggerProvider = new import_sdk_logs2.LoggerProvider({
@@ -1501,13 +1514,16 @@ function getMetricsReader() {
 var import_exporter_trace_otlp_proto = require("@opentelemetry/exporter-trace-otlp-proto");
 
 // src/internal/trace/exporters/span-exporter.ts
+var import_core = require("@opentelemetry/core");
 var import_resources2 = require("@opentelemetry/resources");
 var BrizzSpanExporter = class {
   _delegate;
   _brizzResource;
+  _beforeSendSpan;
   constructor(delegate, config) {
     this._delegate = delegate;
     const resourceAttrs = {
+      ...config.resourceAttributes,
       "service.name": config.appName,
       [BRIZZ_SDK_VERSION]: getSDKVersion(),
       [BRIZZ_SDK_LANGUAGE]: SDK_LANGUAGE
@@ -1515,15 +1531,47 @@ var BrizzSpanExporter = class {
     if (config.environment) {
       resourceAttrs["deployment.environment"] = config.environment;
     }
+    if (config.appVersion) {
+      resourceAttrs["service.version"] = config.appVersion;
+    }
     this._brizzResource = (0, import_resources2.resourceFromAttributes)(resourceAttrs);
+    this._beforeSendSpan = config.beforeSendSpan;
   }
   export(spans, resultCallback) {
+    if (spans.length === 0) {
+      resultCallback({ code: import_core.ExportResultCode.SUCCESS });
+      return;
+    }
     const patchedSpans = spans.map((span) => ({
       ...span,
       resource: span.resource.merge(this._brizzResource),
       spanContext: span.spanContext.bind(span)
     }));
-    this._delegate.export(patchedSpans, resultCallback);
+    const filter = this._beforeSendSpan;
+    if (!filter) {
+      this._delegate.export(patchedSpans, resultCallback);
+      return;
+    }
+    const verdicts = patchedSpans.map((span) => {
+      try {
+        return Promise.resolve(filter(span));
+      } catch (error) {
+        logger.warn("beforeSendSpan threw; span will be kept", { error });
+        return Promise.resolve(true);
+      }
+    });
+    Promise.all(verdicts).then((keep) => {
+      const filtered = patchedSpans.filter((_, i) => keep[i] !== false);
+      if (filtered.length === 0) {
+        resultCallback({ code: import_core.ExportResultCode.SUCCESS });
+        return;
+      }
+      this._delegate.export(filtered, resultCallback);
+      return;
+    }).catch((error) => {
+      logger.warn("beforeSendSpan rejected; all spans will be kept", { error });
+      this._delegate.export(patchedSpans, resultCallback);
+    });
   }
   async shutdown() {
     return this._delegate.shutdown();
@@ -1643,6 +1691,15 @@ var TracingModule = class _TracingModule {
    */
   setup(config) {
     logger.info("Setting up tracing module");
+    if (config.disableSpanExporter) {
+      logger.info(
+        "Span exporter disabled via disableSpanExporter; skipping exporter and processor setup"
+      );
+      this.spanExporter = null;
+      this.spanProcessor = null;
+      _TracingModule.instance = this;
+      return;
+    }
     this.initSpanExporter(config);
     this.initSpanProcessor(config);
     _TracingModule.instance = this;
@@ -1981,6 +2038,7 @@ var _Brizz = class __Brizz {
     const registry = InstrumentationRegistry.getInstance();
     const manualInstrumentations = registry.getManualInstrumentations();
     const resourceAttributes = {
+      ...resolvedConfig.resourceAttributes,
       "service.name": resolvedConfig.appName,
       [BRIZZ_SDK_VERSION]: getSDKVersion(),
       [BRIZZ_SDK_LANGUAGE]: SDK_LANGUAGE
@@ -1988,8 +2046,11 @@ var _Brizz = class __Brizz {
     if (resolvedConfig.environment) {
       resourceAttributes["deployment.environment"] = resolvedConfig.environment;
     }
+    if (resolvedConfig.appVersion) {
+      resourceAttributes["service.version"] = resolvedConfig.appVersion;
+    }
     this._sdk = new import_sdk_node.NodeSDK({
-      spanProcessors: [getSpanProcessor()],
+      spanProcessors: resolvedConfig.disableSpanExporter ? [] : [getSpanProcessor()],
       metricReader: getMetricsReader(),
       resource: (0, import_resources3.resourceFromAttributes)(resourceAttributes),
       instrumentations: manualInstrumentations