@mastra/observability 0.0.0-main-test-05-11-2025-2-20251106053353 → 0.0.0-main-test-2-20251127210604

package/dist/index.cjs

@@ -37,18 +37,38 @@ var observabilityInstanceConfigSchema = zod.z.object({
   serviceName: zod.z.string().min(1, "Service name is required"),
   sampling: samplingStrategySchema.optional(),
   exporters: zod.z.array(zod.z.any()).optional(),
+  bridge: zod.z.any().optional(),
   spanOutputProcessors: zod.z.array(zod.z.any()).optional(),
   includeInternalSpans: zod.z.boolean().optional(),
   requestContextKeys: zod.z.array(zod.z.string()).optional()
-});
+}).refine(
+  (data) => {
+    const hasExporters = data.exporters && data.exporters.length > 0;
+    const hasBridge = !!data.bridge;
+    return hasExporters || hasBridge;
+  },
+  {
+    message: "At least one exporter or a bridge is required"
+  }
+);
 var observabilityConfigValueSchema = zod.z.object({
   serviceName: zod.z.string().min(1, "Service name is required"),
   sampling: samplingStrategySchema.optional(),
   exporters: zod.z.array(zod.z.any()).optional(),
+  bridge: zod.z.any().optional(),
   spanOutputProcessors: zod.z.array(zod.z.any()).optional(),
   includeInternalSpans: zod.z.boolean().optional(),
   requestContextKeys: zod.z.array(zod.z.string()).optional()
-});
+}).refine(
+  (data) => {
+    const hasExporters = data.exporters && data.exporters.length > 0;
+    const hasBridge = !!data.bridge;
+    return hasExporters || hasBridge;
+  },
+  {
+    message: "At least one exporter or a bridge is required"
+  }
+);
 var observabilityRegistryConfigSchema = zod.z.object({
   default: zod.z.object({
     enabled: zod.z.boolean().optional()
@@ -75,6 +95,18 @@ var observabilityRegistryConfigSchema = zod.z.object({
   {
     message: 'A "configSelector" function is required when multiple configs are specified to determine which config to use.'
   }
+).refine(
+  (data) => {
+    if (data.configSelector) {
+      const isDefaultEnabled = data.default?.enabled === true;
+      const hasConfigs = data.configs && typeof data.configs === "object" && !Array.isArray(data.configs) ? Object.keys(data.configs).length > 0 : false;
+      return isDefaultEnabled || hasConfigs;
+    }
+    return true;
+  },
+  {
+    message: 'A "configSelector" requires at least one config or default observability to be configured.'
+  }
 );
 var BaseExporter = class {
   /** Mastra logger instance */
@@ -153,7 +185,7 @@ var CloudExporter = class extends BaseExporter {
     const accessToken = config.accessToken ?? process.env.MASTRA_CLOUD_ACCESS_TOKEN;
     if (!accessToken) {
       this.setDisabled(
-        "MASTRA_CLOUD_ACCESS_TOKEN environment variable not set. \u{1F680} Sign up for Mastra Cloud at https://cloud.mastra.ai to see your traces online and obtain your access token."
+        "MASTRA_CLOUD_ACCESS_TOKEN environment variable not set.\n\u{1F680} Sign up at https://cloud.mastra.ai to see your AI traces online and obtain your access token."
       );
     }
     const endpoint = config.endpoint ?? process.env.MASTRA_CLOUD_TRACES_ENDPOINT ?? "https://api.mastra.ai/ai/spans/publish";
@@ -895,6 +927,27 @@ var DefaultExporter = class extends BaseExporter {
     this.logger.info("DefaultExporter shutdown complete");
   }
 };
+
+// src/exporters/test.ts
+var TestExporter = class extends BaseExporter {
+  name = "tracing-test-exporter";
+  #events = [];
+  constructor(config = {}) {
+    super(config);
+  }
+  async _exportTracingEvent(event) {
+    this.#events.push(event);
+  }
+  clearEvents() {
+    this.#events = [];
+  }
+  get events() {
+    return this.#events;
+  }
+  async shutdown() {
+    this.logger.info("TestExporter shutdown");
+  }
+};
 var ModelSpanTracker = class {
   #modelSpan;
   #currentStepSpan;
@@ -1226,6 +1279,16 @@ function isSpanInternal(spanType, flags) {
       return false;
   }
 }
+function getExternalParentId(options) {
+  if (!options.parent) {
+    return void 0;
+  }
+  if (options.parent.isInternal) {
+    return options.parent.getParentSpanId(false);
+  } else {
+    return options.parent.id;
+  }
+}
 var BaseSpan = class {
   name;
   type;
@@ -1322,6 +1385,28 @@ var BaseSpan = class {
   get externalTraceId() {
     return this.isValid ? this.traceId : void 0;
   }
+  /**
+   * Execute an async function within this span's tracing context.
+   * Delegates to the bridge if available.
+   */
+  async executeInContext(fn) {
+    const bridge = this.observabilityInstance.getBridge();
+    if (bridge?.executeInContext) {
+      return bridge.executeInContext(this.id, fn);
+    }
+    return fn();
+  }
+  /**
+   * Execute a synchronous function within this span's tracing context.
+   * Delegates to the bridge if available.
+   */
+  executeInContextSync(fn) {
+    const bridge = this.observabilityInstance.getBridge();
+    if (bridge?.executeInContextSync) {
+      return bridge.executeInContextSync(this.id, fn);
+    }
+    return fn();
+  }
 };
 var DEFAULT_KEYS_TO_STRIP = /* @__PURE__ */ new Set([
   "logger",
@@ -1368,27 +1453,30 @@ var DefaultSpan = class extends BaseSpan {
   traceId;
   constructor(options, observabilityInstance) {
     super(options, observabilityInstance);
-    this.id = generateSpanId();
+    const bridge = observabilityInstance.getBridge();
+    if (bridge && !this.isInternal) {
+      const bridgeIds = bridge.createSpan(options);
+      if (bridgeIds) {
+        this.id = bridgeIds.spanId;
+        this.traceId = bridgeIds.traceId;
+        this.parentSpanId = bridgeIds.parentSpanId;
+        return;
+      }
+    }
     if (options.parent) {
       this.traceId = options.parent.traceId;
-    } else if (options.traceId) {
-      if (isValidTraceId(options.traceId)) {
-        this.traceId = options.traceId;
-      } else {
-        console.error(
-          `[Mastra Tracing] Invalid traceId: must be 1-32 hexadecimal characters, got "${options.traceId}". Generating new trace ID.`
-        );
-        this.traceId = generateTraceId();
-      }
-    } else {
-      this.traceId = generateTraceId();
+      this.parentSpanId = options.parent.id;
+      this.id = generateSpanId();
+      return;
     }
-    if (!options.parent && options.parentSpanId) {
+    this.traceId = getOrCreateTraceId(options);
+    this.id = generateSpanId();
+    if (options.parentSpanId) {
       if (isValidSpanId(options.parentSpanId)) {
         this.parentSpanId = options.parentSpanId;
       } else {
         console.error(
-          `[Mastra Tracing] Invalid parentSpanId: must be 1-16 hexadecimal characters, got "${options.parentSpanId}". Ignoring parent span ID.`
+          `[Mastra Tracing] Invalid parentSpanId: must be 1-16 hexadecimal characters, got "${options.parentSpanId}". Ignoring.`
         );
       }
     }
@@ -1493,6 +1581,18 @@ function isValidTraceId(traceId) {
 function isValidSpanId(spanId) {
   return /^[0-9a-f]{1,16}$/i.test(spanId);
 }
+function getOrCreateTraceId(options) {
+  if (options.traceId) {
+    if (isValidTraceId(options.traceId)) {
+      return options.traceId;
+    } else {
+      console.error(
+        `[Mastra Tracing] Invalid traceId: must be 1-32 hexadecimal characters, got "${options.traceId}". Generating new trace ID.`
+      );
+    }
+  }
+  return generateTraceId();
+}
 
 // src/spans/no-op.ts
 var NoOpSpan = class extends BaseSpan {
@@ -1525,13 +1625,17 @@ var BaseObservabilityInstance = class extends base.MastraBase {
       sampling: config.sampling ?? { type: "always" /* ALWAYS */ },
       exporters: config.exporters ?? [],
       spanOutputProcessors: config.spanOutputProcessors ?? [],
+      bridge: config.bridge ?? void 0,
       includeInternalSpans: config.includeInternalSpans ?? false,
       requestContextKeys: config.requestContextKeys ?? []
     };
+    if (this.config.bridge?.init) {
+      this.config.bridge.init({ config: this.config });
+    }
   }
   /**
    * Override setLogger to add Observability specific initialization log
-   * and propagate logger to exporters
+   * and propagate logger to exporters and bridge
    */
   __setLogger(logger) {
     super.__setLogger(logger);
@@ -1540,8 +1644,11 @@ var BaseObservabilityInstance = class extends base.MastraBase {
         exporter.__setLogger(logger);
       }
     });
+    if (this.config.bridge?.__setLogger) {
+      this.config.bridge.__setLogger(logger);
+    }
     this.logger.debug(
-      `[Observability] Initialized [service=${this.config.serviceName}] [instance=${this.config.name}] [sampling=${this.config.sampling.type}]`
+      `[Observability] Initialized [service=${this.config.serviceName}] [instance=${this.config.name}] [sampling=${this.config.sampling?.type}] [bridge=${!!this.config.bridge}]`
     );
   }
   // ============================================================================
@@ -1608,6 +1715,12 @@ var BaseObservabilityInstance = class extends base.MastraBase {
   getSpanOutputProcessors() {
     return [...this.spanOutputProcessors];
   }
+  /**
+   * Get the bridge instance if configured
+   */
+  getBridge() {
+    return this.config.bridge;
+  }
   /**
    * Get the logger instance (for exporters and other components)
    */
@@ -1652,7 +1765,9 @@ var BaseObservabilityInstance = class extends base.MastraBase {
    */
   shouldSample(options) {
     const { sampling } = this.config;
-    switch (sampling.type) {
+    switch (sampling?.type) {
+      case void 0:
+        return true;
       case "always" /* ALWAYS */:
         return true;
       case "never" /* NEVER */:
@@ -1784,17 +1899,21 @@ var BaseObservabilityInstance = class extends base.MastraBase {
     }
   }
   /**
-   * Export tracing event through all exporters (realtime mode)
+   * Export tracing event through all exporters and bridge (realtime mode)
    */
   async exportTracingEvent(event) {
-    const exportPromises = this.exporters.map(async (exporter) => {
+    const targets = [
+      ...this.exporters
+    ];
+    if (this.config.bridge) {
+      targets.push(this.config.bridge);
+    }
+    const exportPromises = targets.map(async (target) => {
       try {
-        if (exporter.exportTracingEvent) {
-          await exporter.exportTracingEvent(event);
-          this.logger.debug(`[Observability] Event exported [exporter=${exporter.name}] [type=${event.type}]`);
-        }
+        await target.exportTracingEvent(event);
+        this.logger.debug(`[Observability] Event exported [target=${target.name}] [type=${event.type}]`);
       } catch (error) {
-        this.logger.error(`[Observability] Export error [exporter=${exporter.name}]`, error);
+        this.logger.error(`[Observability] Export error [target=${target.name}]`, error);
       }
     });
     await Promise.allSettled(exportPromises);
@@ -1818,6 +1937,9 @@ var BaseObservabilityInstance = class extends base.MastraBase {
       ...this.exporters.map((e) => e.shutdown()),
       ...this.spanOutputProcessors.map((p) => p.shutdown())
     ];
+    if (this.config.bridge) {
+      shutdownPromises.push(this.config.bridge.shutdown());
+    }
     await Promise.allSettled(shutdownPromises);
     this.logger.info(`[Observability] Shutdown completed [name=${this.name}]`);
   }
@@ -2184,7 +2306,9 @@ exports.NoOpSpan = NoOpSpan;
 exports.Observability = Observability;
 exports.SamplingStrategyType = SamplingStrategyType;
 exports.SensitiveDataFilter = SensitiveDataFilter;
+exports.TestExporter = TestExporter;
 exports.deepClean = deepClean;
+exports.getExternalParentId = getExternalParentId;
 exports.observabilityConfigValueSchema = observabilityConfigValueSchema;
 exports.observabilityInstanceConfigSchema = observabilityInstanceConfigSchema;
 exports.observabilityRegistryConfigSchema = observabilityRegistryConfigSchema;