@mastra/core 0.13.2 → 0.14.0-alpha.1

package/dist/ai-tracing/index.js

@@ -1,36 +1,47 @@
 import { MastraError } from '../chunk-4O4YNORN.js';
-import { MastraBase } from '../chunk-FUERFM46.js';
-import { ConsoleLogger, RegisteredLogger } from '../chunk-6AR2Z5ZG.js';
+import { MastraBase } from '../chunk-6GF5M4GX.js';
+import { ConsoleLogger, LogLevel, RegisteredLogger } from '../chunk-X3GXU6TZ.js';
 
 // src/ai-tracing/no-op.ts
 var NoOpAISpan = class _NoOpAISpan {
   id;
   name;
   type;
-  metadata;
+  attributes;
+  parent;
   trace;
   traceId;
   startTime;
   endTime;
   aiTracing;
+  input;
+  output;
+  errorInfo;
+  metadata;
   constructor(options, aiTracing) {
     this.id = "no-op";
     this.name = options.name;
     this.type = options.type;
+    this.attributes = options.attributes || {};
     this.metadata = options.metadata;
+    this.parent = options.parent;
     this.trace = options.parent ? options.parent.trace : this;
     this.traceId = "no-op-trace";
     this.startTime = /* @__PURE__ */ new Date();
     this.aiTracing = aiTracing;
+    this.input = options.input;
+  }
+  end(_options) {
   }
-  end() {
+  error(_options) {
   }
-  error() {
+  createChildSpan(options) {
+    return new _NoOpAISpan({ ...options, parent: this }, this.aiTracing);
   }
-  createChildSpan(type, name, metadata) {
-    return new _NoOpAISpan({ type, name, metadata, parent: this }, this.aiTracing);
+  update(_options) {
   }
-  update() {
+  get isRootSpan() {
+    return !this.parent;
   }
 };
 
@@ -63,9 +74,23 @@ var AITracingEventType = /* @__PURE__ */ ((AITracingEventType2) => {
 var MastraAITracing = class extends MastraBase {
   config;
   constructor(config) {
-    super({ component: RegisteredLogger.AI_TELEMETRY, name: config.serviceName });
-    this.config = config;
-    this.logger.debug(`AI Tracing initialized [service=${config.serviceName}] [sampling=${this.config.sampling.type}]`);
+    super({ component: RegisteredLogger.AI_TRACING, name: config.serviceName });
+    this.config = {
+      serviceName: config.serviceName,
+      instanceName: config.instanceName,
+      sampling: config.sampling ?? { type: "always" /* ALWAYS */ },
+      exporters: config.exporters ?? [],
+      processors: config.processors ?? []
+    };
+  }
+  /**
+   * Override setLogger to add AI tracing specific initialization log
+   */
+  __setLogger(logger) {
+    super.__setLogger(logger);
+    this.logger.debug(
+      `[AI Tracing] Initialized [service=${this.config.serviceName}] [instance=${this.config.instanceName}] [sampling=${this.config.sampling.type}]`
+    );
   }
   // ============================================================================
   // Protected getters for clean config access
@@ -82,18 +107,21 @@ var MastraAITracing = class extends MastraBase {
   /**
    * Start a new span of a specific AISpanType
    */
-  startSpan(type, name, metadata, parent, runtimeContext, attributes) {
-    if (!this.shouldSample({ runtimeContext, attributes })) {
-      return new NoOpAISpan({ type, name, metadata, parent }, this);
+  startSpan(options) {
+    const { type, name, input, attributes, metadata, parent, startOptions } = options;
+    const { runtimeContext } = startOptions || {};
+    if (!this.shouldSample({ runtimeContext })) {
+      return new NoOpAISpan({ type, name, input, attributes, metadata, parent }, this);
     }
-    const options = {
+    const spanOptions = {
       type,
       name,
+      input,
+      attributes,
       metadata,
       parent
     };
-    const span = this.createSpan(options);
-    span.trace = parent ? parent.trace : span;
+    const span = this.createSpan(spanOptions);
     this.wireSpanLifecycle(span);
     this.emitSpanStarted(span);
     return span;
@@ -138,12 +166,12 @@ var MastraAITracing = class extends MastraBase {
   wireSpanLifecycle(span) {
     const originalEnd = span.end.bind(span);
     const originalUpdate = span.update.bind(span);
-    span.end = (metadata) => {
-      originalEnd(metadata);
+    span.end = (options) => {
+      originalEnd(options);
       this.emitSpanEnded(span);
     };
-    span.update = (metadata) => {
-      originalUpdate(metadata);
+    span.update = (options) => {
+      originalUpdate(options);
       this.emitSpanUpdated(span);
     };
   }
@@ -186,7 +214,7 @@ var MastraAITracing = class extends MastraBase {
       try {
         processedSpan = processor.process(processedSpan);
       } catch (error) {
-        this.logger.error(`Processor error [name=${processor.name}]`, error);
+        this.logger.error(`[AI Tracing] Processor error [name=${processor.name}]`, error);
       }
     }
     return processedSpan;
@@ -201,7 +229,7 @@ var MastraAITracing = class extends MastraBase {
     const processedSpan = this.processSpan(span);
     if (processedSpan) {
       this.exportEvent({ type: "span_started" /* SPAN_STARTED */, span: processedSpan }).catch((error) => {
-        this.logger.error("Failed to export span_started event", error);
+        this.logger.error("[AI Tracing] Failed to export span_started event", error);
       });
     }
   }
@@ -212,7 +240,7 @@ var MastraAITracing = class extends MastraBase {
     const processedSpan = this.processSpan(span);
     if (processedSpan) {
       this.exportEvent({ type: "span_ended" /* SPAN_ENDED */, span: processedSpan }).catch((error) => {
-        this.logger.error("Failed to export span_ended event", error);
+        this.logger.error("[AI Tracing] Failed to export span_ended event", error);
       });
     }
   }
@@ -223,7 +251,7 @@ var MastraAITracing = class extends MastraBase {
     const processedSpan = this.processSpan(span);
     if (processedSpan) {
       this.exportEvent({ type: "span_updated" /* SPAN_UPDATED */, span: processedSpan }).catch((error) => {
-        this.logger.error("Failed to export span_updated event", error);
+        this.logger.error("[AI Tracing] Failed to export span_updated event", error);
       });
     }
   }
@@ -235,10 +263,10 @@ var MastraAITracing = class extends MastraBase {
       try {
         if (exporter.exportEvent) {
           await exporter.exportEvent(event);
-          this.logger.debug(`Event exported [exporter=${exporter.name}] [type=${event.type}]`);
+          this.logger.debug(`[AI Tracing] Event exported [exporter=${exporter.name}] [type=${event.type}]`);
         }
       } catch (error) {
-        this.logger.error(`Export error [exporter=${exporter.name}]`, error);
+        this.logger.error(`[AI Tracing] Export error [exporter=${exporter.name}]`, error);
       }
     });
     await Promise.allSettled(exportPromises);
@@ -250,17 +278,17 @@ var MastraAITracing = class extends MastraBase {
    * Initialize AI tracing (called by Mastra during component registration)
    */
   async init() {
-    this.logger.debug(`AI Tracing initialization started [name=${this.name}]`);
-    this.logger.info(`AI Tracing initialized successfully [name=${this.name}]`);
+    this.logger.debug(`[AI Tracing] Initialization started [name=${this.name}]`);
+    this.logger.info(`[AI Tracing] Initialized successfully [name=${this.name}]`);
   }
   /**
    * Shutdown AI tracing and clean up resources
    */
   async shutdown() {
-    this.logger.debug(`AI Tracing shutdown started [name=${this.name}]`);
+    this.logger.debug(`[AI Tracing] Shutdown started [name=${this.name}]`);
     const shutdownPromises = [...this.exporters.map((e) => e.shutdown()), ...this.processors.map((p) => p.shutdown())];
     await Promise.allSettled(shutdownPromises);
-    this.logger.info(`AI Tracing shutdown completed [name=${this.name}]`);
+    this.logger.info(`[AI Tracing] Shutdown completed [name=${this.name}]`);
   }
 };
 
@@ -291,61 +319,96 @@ var DefaultAISpan = class {
   id;
   name;
   type;
-  metadata;
+  attributes;
+  parent;
   trace;
   traceId;
   startTime;
   endTime;
   aiTracing;
+  input;
+  output;
+  errorInfo;
+  metadata;
   constructor(options, aiTracing) {
     this.id = generateSpanId();
     this.name = options.name;
     this.type = options.type;
+    this.attributes = options.attributes || {};
     this.metadata = options.metadata;
+    this.parent = options.parent;
     this.trace = options.parent ? options.parent.trace : this;
     this.startTime = /* @__PURE__ */ new Date();
     this.aiTracing = aiTracing;
+    this.input = options.input;
     if (!options.parent) {
       this.traceId = generateTraceId();
     } else {
       this.traceId = options.parent.trace.traceId;
     }
   }
-  end(metadata) {
+  end(options) {
     this.endTime = /* @__PURE__ */ new Date();
-    if (metadata) {
-      this.metadata = { ...this.metadata, ...metadata };
+    if (options?.output !== void 0) {
+      this.output = options.output;
+    }
+    if (options?.attributes) {
+      this.attributes = { ...this.attributes, ...options.attributes };
+    }
+    if (options?.metadata) {
+      this.metadata = { ...this.metadata, ...options.metadata };
     }
   }
-  error(error, endSpan = true) {
-    const errorMetadata = error instanceof MastraError ? {
-      error: {
-        id: error.id,
-        details: error.details,
-        category: error.category,
-        domain: error.domain,
-        message: error.message
-      }
+  error(options) {
+    const { error, endSpan = true, attributes, metadata } = options;
+    this.errorInfo = error instanceof MastraError ? {
+      id: error.id,
+      details: error.details,
+      category: error.category,
+      domain: error.domain,
+      message: error.message
     } : {
-      error: {
-        message: error.message
-      }
+      message: error.message
     };
+    if (attributes) {
+      this.attributes = { ...this.attributes, ...attributes };
+    }
+    if (metadata) {
+      this.metadata = { ...this.metadata, ...metadata };
+    }
     if (endSpan) {
-      this.end(errorMetadata);
+      this.end();
     } else {
-      this.update(errorMetadata);
+      this.update({});
     }
   }
-  createChildSpan(type, name, metadata) {
-    return this.aiTracing.startSpan(type, name, metadata, this);
+  createChildSpan(options) {
+    return this.aiTracing.startSpan({
+      ...options,
+      parent: this
+    });
+  }
+  update(options) {
+    if (options?.input !== void 0) {
+      this.input = options.input;
+    }
+    if (options?.output !== void 0) {
+      this.output = options.output;
+    }
+    if (options?.attributes) {
+      this.attributes = { ...this.attributes, ...options.attributes };
+    }
+    if (options?.metadata) {
+      this.metadata = { ...this.metadata, ...options.metadata };
+    }
   }
-  update(metadata) {
-    this.metadata = { ...this.metadata, ...metadata };
+  get isRootSpan() {
+    return !this.parent;
   }
   async export() {
     return JSON.stringify({
       id: this.id,
+      attributes: this.attributes,
       metadata: this.metadata,
       startTime: this.startTime,
       endTime: this.endTime,
@@ -400,12 +463,16 @@ var SensitiveDataFilter = class {
     };
     try {
       const filteredSpan = { ...span };
+      filteredSpan.attributes = deepFilter(span.attributes);
       filteredSpan.metadata = deepFilter(span.metadata);
+      filteredSpan.input = deepFilter(span.input);
+      filteredSpan.output = deepFilter(span.output);
+      filteredSpan.errorInfo = deepFilter(span.errorInfo);
       return filteredSpan;
     } catch (error) {
       const safeSpan = { ...span };
-      safeSpan.metadata = {
-        "[FILTERING_ERROR]": "Metadata was completely redacted due to filtering error",
+      safeSpan.attributes = {
+        "[FILTERING_ERROR]": "Attributes were completely redacted due to filtering error",
         "[ERROR_MESSAGE]": error instanceof Error ? error.message : "Unknown filtering error"
       };
       return safeSpan;
@@ -422,18 +489,20 @@ var DefaultConsoleExporter = class {
       this.logger = logger;
     } else {
       this.logger = new ConsoleLogger({
-        name: "default-console-exporter"
+        name: "default-console-exporter",
+        level: LogLevel.INFO
+        // Set to INFO so that info() calls actually log
       });
     }
   }
   async exportEvent(event) {
     const span = event.span;
-    const formatMetadata = (metadata) => {
+    const formatAttributes = (attributes) => {
       try {
-        return JSON.stringify(metadata, null, 2);
+        return JSON.stringify(attributes, null, 2);
       } catch (error) {
         const errMsg = error instanceof Error ? error.message : "Unknown formatting error";
-        return `[Unable to serialize metadata: ${errMsg}]`;
+        return `[Unable to serialize attributes: ${errMsg}]`;
       }
     };
     const formatDuration = (startTime, endTime) => {
@@ -448,7 +517,10 @@ var DefaultConsoleExporter = class {
         this.logger.info(`   Name: ${span.name}`);
         this.logger.info(`   ID: ${span.id}`);
         this.logger.info(`   Trace ID: ${span.traceId}`);
-        this.logger.info(`   Metadata: ${formatMetadata(span.metadata)}`);
+        if (span.input !== void 0) {
+          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
+        }
+        this.logger.info(`   Attributes: ${formatAttributes(span.attributes)}`);
         this.logger.info("\u2500".repeat(80));
         break;
       case "span_ended" /* SPAN_ENDED */:
@@ -459,7 +531,16 @@ var DefaultConsoleExporter = class {
         this.logger.info(`   ID: ${span.id}`);
         this.logger.info(`   Duration: ${duration}`);
         this.logger.info(`   Trace ID: ${span.traceId}`);
-        this.logger.info(`   Final Metadata: ${formatMetadata(span.metadata)}`);
+        if (span.input !== void 0) {
+          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
+        }
+        if (span.output !== void 0) {
+          this.logger.info(`   Output: ${formatAttributes(span.output)}`);
+        }
+        if (span.errorInfo) {
+          this.logger.info(`   Error: ${formatAttributes(span.errorInfo)}`);
+        }
+        this.logger.info(`   Attributes: ${formatAttributes(span.attributes)}`);
         this.logger.info("\u2500".repeat(80));
         break;
       case "span_updated" /* SPAN_UPDATED */:
@@ -468,7 +549,16 @@ var DefaultConsoleExporter = class {
         this.logger.info(`   Name: ${span.name}`);
         this.logger.info(`   ID: ${span.id}`);
         this.logger.info(`   Trace ID: ${span.traceId}`);
-        this.logger.info(`   Updated Metadata: ${formatMetadata(span.metadata)}`);
+        if (span.input !== void 0) {
+          this.logger.info(`   Input: ${formatAttributes(span.input)}`);
+        }
+        if (span.output !== void 0) {
+          this.logger.info(`   Output: ${formatAttributes(span.output)}`);
+        }
+        if (span.errorInfo) {
+          this.logger.info(`   Error: ${formatAttributes(span.errorInfo)}`);
+        }
+        this.logger.info(`   Updated Attributes: ${formatAttributes(span.attributes)}`);
         this.logger.info("\u2500".repeat(80));
         break;
       default:
@@ -481,6 +571,7 @@ var DefaultConsoleExporter = class {
 };
 var aiTracingDefaultConfig = {
   serviceName: "mastra-ai-service",
+  instanceName: "default",
   sampling: { type: "always" /* ALWAYS */ },
   exporters: [new DefaultConsoleExporter()],
   // Uses its own fallback logger
@@ -502,10 +593,14 @@ var DefaultAITracing = class extends MastraAITracing {
 var AITracingRegistry = class {
   instances = /* @__PURE__ */ new Map();
   defaultInstance;
+  selector;
   /**
    * Register a tracing instance
    */
   register(name, instance, isDefault = false) {
+    if (this.instances.has(name)) {
+      throw new Error(`AI Tracing instance '${name}' already registered`);
+    }
     this.instances.set(name, instance);
     if (isDefault || !this.defaultInstance) {
       this.defaultInstance = instance;
@@ -515,8 +610,29 @@ var AITracingRegistry = class {
    * Get a tracing instance by name
    */
   get(name) {
-    if (name) {
-      return this.instances.get(name);
+    return this.instances.get(name);
+  }
+  /**
+   * Get the default tracing instance
+   */
+  getDefault() {
+    return this.defaultInstance;
+  }
+  /**
+   * Set the tracing selector function
+   */
+  setSelector(selector) {
+    this.selector = selector;
+  }
+  /**
+   * Get the selected tracing instance based on context
+   */
+  getSelected(context) {
+    if (this.selector) {
+      const selected = this.selector(context, this.instances);
+      if (selected && this.instances.has(selected)) {
+        return this.instances.get(selected);
+      }
     }
     return this.defaultInstance;
   }
@@ -524,19 +640,23 @@ var AITracingRegistry = class {
    * Unregister a tracing instance
    */
   unregister(name) {
-    const instance = this.instances.get(name);
-    if (instance && instance === this.defaultInstance) {
-      const remaining = Array.from(this.instances.values()).filter((i) => i !== instance);
-      this.defaultInstance = remaining[0];
-    }
     return this.instances.delete(name);
   }
   /**
-   * Clear all instances
+   * Shutdown all instances and clear the registry
+   */
+  async shutdown() {
+    const shutdownPromises = Array.from(this.instances.values()).map((instance) => instance.shutdown());
+    await Promise.allSettled(shutdownPromises);
+    this.instances.clear();
+  }
+  /**
+   * Clear all instances without shutdown
    */
   clear() {
     this.instances.clear();
     this.defaultInstance = void 0;
+    this.selector = void 0;
   }
   /**
    * Get all registered instances
@@ -552,12 +672,27 @@ function registerAITracing(name, instance, isDefault = false) {
 function getAITracing(name) {
   return aiTracingRegistry.get(name);
 }
+function getDefaultAITracing() {
+  return aiTracingRegistry.getDefault();
+}
+function setAITracingSelector(selector) {
+  aiTracingRegistry.setSelector(selector);
+}
+function getSelectedAITracing(context) {
+  return aiTracingRegistry.getSelected(context);
+}
 function unregisterAITracing(name) {
   return aiTracingRegistry.unregister(name);
 }
+async function shutdownAITracingRegistry() {
+  await aiTracingRegistry.shutdown();
+}
 function clearAITracingRegistry() {
   aiTracingRegistry.clear();
 }
+function getAllAITracing() {
+  return aiTracingRegistry.getAll();
+}
 function hasAITracing(name) {
   const tracing = getAITracing(name);
   if (!tracing) return false;
@@ -565,7 +700,44 @@ function hasAITracing(name) {
   const sampling = config.sampling;
   return sampling.type !== "never" /* NEVER */;
 }
+function isAITracingInstance(obj) {
+  return obj instanceof MastraAITracing;
+}
+function setupAITracing(config) {
+  const entries = Object.entries(config.instances);
+  entries.forEach(([name, tracingDef], index) => {
+    const instance = isAITracingInstance(tracingDef) ? tracingDef : new DefaultAITracing({ ...tracingDef, instanceName: name });
+    const isDefault = index === 0;
+    registerAITracing(name, instance, isDefault);
+  });
+  if (config.selector) {
+    setAITracingSelector(config.selector);
+  }
+}
+
+// src/ai-tracing/utils.ts
+function sanitizeMetadata(metadata) {
+  if (!metadata) return {};
+  const sanitized = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    if (isSerializable(value)) {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+function isSerializable(value) {
+  try {
+    JSON.stringify(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function omitKeys(obj, keysToOmit) {
+  return Object.fromEntries(Object.entries(obj).filter(([key]) => !keysToOmit.includes(key)));
+}
 
-export { AISpanType, AITracingEventType, DefaultAITracing, DefaultConsoleExporter, MastraAITracing, SamplingStrategyType, SensitiveDataFilter, aiTracingDefaultConfig, clearAITracingRegistry, getAITracing, hasAITracing, registerAITracing, unregisterAITracing };
+export { AISpanType, AITracingEventType, DefaultAITracing, DefaultConsoleExporter, MastraAITracing, SamplingStrategyType, SensitiveDataFilter, aiTracingDefaultConfig, clearAITracingRegistry, getAITracing, getAllAITracing, getDefaultAITracing, getSelectedAITracing, hasAITracing, isSerializable, omitKeys, registerAITracing, sanitizeMetadata, setAITracingSelector, setupAITracing, shutdownAITracingRegistry, unregisterAITracing };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map