@mastra/core 0.2.0-alpha.99 → 0.2.0

package/dist/chunk-FGZVE4CM.js

@@ -0,0 +1,404 @@
+import { TABLE_TRACES } from './chunk-RG66XEJT.js';
+import { trace, context, propagation, SpanStatusCode, SpanKind } from '@opentelemetry/api';
+import { ExportResultCode } from '@opentelemetry/core';
+import { JsonTraceSerializer } from '@opentelemetry/otlp-transformer';
+import '@opentelemetry/sdk-trace-base';
+
+function hasActiveTelemetry(tracerName = "default-tracer") {
+  try {
+    return !!trace.getTracer(tracerName);
+  } catch {
+    return false;
+  }
+}
+
+// src/telemetry/telemetry.decorators.ts
+function withSpan(options) {
+  return function(_target, propertyKey, descriptor) {
+    if (!descriptor || typeof descriptor === "number") return;
+    const originalMethod = descriptor.value;
+    const methodName = String(propertyKey);
+    descriptor.value = function(...args) {
+      if (options?.skipIfNoTelemetry && !hasActiveTelemetry(options?.tracerName)) {
+        return originalMethod.apply(this, args);
+      }
+      const tracer = trace.getTracer(options?.tracerName ?? "default-tracer");
+      let spanName;
+      let spanKind;
+      if (typeof options === "string") {
+        spanName = options;
+      } else if (options) {
+        spanName = options.spanName || methodName;
+        spanKind = options.spanKind;
+      } else {
+        spanName = methodName;
+      }
+      const span = tracer.startSpan(spanName, { kind: spanKind });
+      let ctx = trace.setSpan(context.active(), span);
+      args.forEach((arg, index) => {
+        try {
+          span.setAttribute(`${spanName}.argument.${index}`, JSON.stringify(arg));
+        } catch (e) {
+          span.setAttribute(`${spanName}.argument.${index}`, "[Not Serializable]");
+        }
+      });
+      const currentBaggage = propagation.getBaggage(ctx);
+      if (currentBaggage?.componentName) {
+        span.setAttribute("componentName", currentBaggage?.componentName);
+        span.setAttribute("runId", currentBaggage?.runId);
+      } else if (this && this.name) {
+        span.setAttribute("componentName", this.name);
+        span.setAttribute("runId", this.runId);
+        ctx = propagation.setBaggage(ctx, { componentName: this.name, runId: this.runId });
+      }
+      let result;
+      try {
+        result = context.with(ctx, () => originalMethod.apply(this, args));
+        if (result instanceof Promise) {
+          return result.then((resolvedValue) => {
+            try {
+              span.setAttribute(`${spanName}.result`, JSON.stringify(resolvedValue));
+            } catch (e) {
+              span.setAttribute(`${spanName}.result`, "[Not Serializable]");
+            }
+            return resolvedValue;
+          }).finally(() => span.end());
+        }
+        try {
+          span.setAttribute(`${spanName}.result`, JSON.stringify(result));
+        } catch (e) {
+          span.setAttribute(`${spanName}.result`, "[Not Serializable]");
+        }
+        return result;
+      } catch (error) {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: error instanceof Error ? error.message : "Unknown error"
+        });
+        if (error instanceof Error) {
+          span.recordException(error);
+        }
+        throw error;
+      } finally {
+        if (!(result instanceof Promise)) {
+          span.end();
+        }
+      }
+    };
+    return descriptor;
+  };
+}
+function InstrumentClass(options) {
+  return function(target) {
+    const methods = Object.getOwnPropertyNames(target.prototype);
+    methods.forEach((method) => {
+      if (options?.excludeMethods?.includes(method) || method === "constructor") return;
+      if (options?.methodFilter && !options.methodFilter(method)) return;
+      const descriptor = Object.getOwnPropertyDescriptor(target.prototype, method);
+      if (descriptor && typeof descriptor.value === "function") {
+        Object.defineProperty(
+          target.prototype,
+          method,
+          withSpan({
+            spanName: options?.prefix ? `${options.prefix}.${method}` : method,
+            skipIfNoTelemetry: true,
+            spanKind: options?.spanKind || SpanKind.INTERNAL,
+            tracerName: options?.tracerName
+          })(target, method, descriptor)
+        );
+      }
+    });
+    return target;
+  };
+}
+var OTLPTraceExporter = class {
+  storage;
+  queue = [];
+  serializer;
+  logger;
+  activeFlush = undefined;
+  constructor({ logger, storage }) {
+    this.storage = storage;
+    this.serializer = JsonTraceSerializer;
+    this.logger = logger;
+  }
+  export(internalRepresentation, resultCallback) {
+    const serializedRequest = this.serializer.serializeRequest(internalRepresentation);
+    const payload = JSON.parse(Buffer.from(serializedRequest.buffer, "utf8"));
+    const items = payload?.resourceSpans?.[0]?.scopeSpans;
+    this.logger.debug(`Exporting telemetry: ${items.length} scope spans to be processed [trace batch]`);
+    this.queue.push({ data: items, resultCallback });
+    if (!this.activeFlush) {
+      this.activeFlush = this.flush();
+    }
+  }
+  shutdown() {
+    return this.forceFlush();
+  }
+  flush() {
+    const now = /* @__PURE__ */ new Date();
+    const items = this.queue.shift();
+    if (!items) return Promise.resolve();
+    const allSpans = items.data.reduce((acc, scopedSpans) => {
+      const { scope, spans } = scopedSpans;
+      for (const span of spans) {
+        const {
+          spanId,
+          parentSpanId,
+          traceId,
+          name,
+          kind,
+          attributes,
+          status,
+          events,
+          links,
+          startTimeUnixNano,
+          endTimeUnixNano,
+          ...rest
+        } = span;
+        const startTime = Number(BigInt(startTimeUnixNano) / 1000n);
+        const endTime = Number(BigInt(endTimeUnixNano) / 1000n);
+        acc.push({
+          id: spanId,
+          parentSpanId,
+          traceId,
+          name,
+          scope: scope.name,
+          kind,
+          status: JSON.stringify(status),
+          events: JSON.stringify(events),
+          links: JSON.stringify(links),
+          attributes: JSON.stringify(
+            attributes.reduce((acc2, attr) => {
+              const valueKey = Object.keys(attr.value)[0];
+              if (valueKey) {
+                acc2[attr.key] = attr.value[valueKey];
+              }
+              return acc2;
+            }, {})
+          ),
+          startTime,
+          endTime,
+          other: JSON.stringify(rest),
+          createdAt: now
+        });
+      }
+      return acc;
+    }, []);
+    return this.storage.__batchInsert({
+      tableName: TABLE_TRACES,
+      records: allSpans
+    }).then(() => {
+      items.resultCallback({
+        code: ExportResultCode.SUCCESS
+      });
+    }).catch((e) => {
+      this.logger.error("span err:" + e?.message);
+      items.resultCallback({
+        code: ExportResultCode.FAILED,
+        error: e
+      });
+    }).finally(() => {
+      this.activeFlush = undefined;
+    });
+  }
+  async forceFlush() {
+    if (!this.queue.length) {
+      return;
+    }
+    await this.activeFlush;
+    while (this.queue.length) {
+      await this.flush();
+    }
+  }
+  __setLogger(logger) {
+    this.logger = logger;
+  }
+};
+var Telemetry = class _Telemetry {
+  tracer = trace.getTracer("default");
+  name = "default-service";
+  constructor(config) {
+    this.name = config.serviceName ?? "default-service";
+    this.tracer = trace.getTracer(this.name);
+  }
+  /**
+   * @deprecated This method does not do anything
+   */
+  async shutdown() {
+  }
+  /**
+   * Initialize telemetry with the given configuration
+   * @param config - Optional telemetry configuration object
+   * @returns Telemetry instance that can be used for tracing
+   */
+  static init(config = {}) {
+    try {
+      if (!global.__TELEMETRY__) {
+        global.__TELEMETRY__ = new _Telemetry(config);
+      }
+      return global.__TELEMETRY__;
+    } catch (error) {
+      console.error("Failed to initialize telemetry:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get the global telemetry instance
+   * @throws {Error} If telemetry has not been initialized
+   * @returns {Telemetry} The global telemetry instance
+   */
+  static get() {
+    if (!global.__TELEMETRY__) {
+      throw new Error("Telemetry not initialized");
+    }
+    return global.__TELEMETRY__;
+  }
+  /**
+   * Wraps a class instance with telemetry tracing
+   * @param instance The class instance to wrap
+   * @param options Optional configuration for tracing
+   * @returns Wrapped instance with all methods traced
+   */
+  traceClass(instance, options = {}) {
+    const { skipIfNoTelemetry = true } = options;
+    if (skipIfNoTelemetry && !hasActiveTelemetry()) {
+      return instance;
+    }
+    const { spanNamePrefix = instance.constructor.name.toLowerCase(), attributes = {}, excludeMethods = [] } = options;
+    return new Proxy(instance, {
+      get: (target, prop) => {
+        const value = target[prop];
+        if (typeof value === "function" && prop !== "constructor" && !prop.toString().startsWith("_") && !excludeMethods.includes(prop.toString())) {
+          return this.traceMethod(value.bind(target), {
+            spanName: `${spanNamePrefix}.${prop.toString()}`,
+            attributes: {
+              ...attributes,
+              [`${spanNamePrefix}.name`]: target.constructor.name,
+              [`${spanNamePrefix}.method.name`]: prop.toString()
+            }
+          });
+        }
+        return value;
+      }
+    });
+  }
+  /**
+   * method to trace individual methods with proper context
+   * @param method The method to trace
+   * @param context Additional context for the trace
+   * @returns Wrapped method with tracing
+   */
+  traceMethod(method, context3) {
+    let ctx = context.active();
+    const { skipIfNoTelemetry = true } = context3;
+    if (skipIfNoTelemetry && !hasActiveTelemetry()) {
+      return method;
+    }
+    return (...args) => {
+      const span = this.tracer.startSpan(context3.spanName);
+      function handleError(error) {
+        span.recordException(error);
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: error.message
+        });
+        span.end();
+        throw error;
+      }
+      try {
+        let recordResult2 = function(res) {
+          try {
+            span.setAttribute(`${context3.spanName}.result`, JSON.stringify(res));
+          } catch (e) {
+            span.setAttribute(`${context3.spanName}.result`, "[Not Serializable]");
+          }
+          span.end();
+          return res;
+        };
+        var recordResult = recordResult2;
+        if (context3.attributes) {
+          span.setAttributes(context3.attributes);
+        }
+        if (context3.attributes?.componentName) {
+          ctx = propagation.setBaggage(ctx, {
+            // @ts-ignore
+            componentName: context3.attributes.componentName,
+            runId: context3.attributes.runId
+          });
+        } else {
+          const currentBaggage = propagation.getBaggage(ctx);
+          if (currentBaggage?.componentName) {
+            span.setAttribute("componentName", currentBaggage?.componentName);
+            span.setAttribute("runId", currentBaggage?.runId);
+          } else if (this && this.name) {
+            span.setAttribute("componentName", this.name);
+            span.setAttribute("runId", this.runId);
+            ctx = propagation.setBaggage(ctx, { componentName: this.name, runId: this.runId });
+          }
+        }
+        args.forEach((arg, index) => {
+          try {
+            span.setAttribute(`${context3.spanName}.argument.${index}`, JSON.stringify(arg));
+          } catch (e) {
+            span.setAttribute(`${context3.spanName}.argument.${index}`, "[Not Serializable]");
+          }
+        });
+        let result;
+        context.with(trace.setSpan(ctx, span), () => {
+          result = method(...args);
+        });
+        if (result instanceof Promise) {
+          return result.then(recordResult2).catch(handleError);
+        } else {
+          return recordResult2(result);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    };
+  }
+  getBaggageTracer() {
+    return new BaggageTracer(this.tracer);
+  }
+};
+var BaggageTracer = class {
+  _tracer;
+  constructor(tracer) {
+    this._tracer = tracer;
+  }
+  startSpan(name, options = {}, ctx) {
+    ctx = ctx ?? context.active();
+    const span = this._tracer.startSpan(name, options, ctx);
+    const currentBaggage = propagation.getBaggage(ctx);
+    span.setAttribute("componentName", currentBaggage?.componentName);
+    span.setAttribute("runId", currentBaggage?.runId);
+    return span;
+  }
+  startActiveSpan(name, optionsOrFn, ctxOrFn, fn) {
+    if (typeof optionsOrFn === "function") {
+      const wrappedFn2 = (span) => {
+        const currentBaggage = propagation.getBaggage(context.active());
+        span.setAttribute("componentName", currentBaggage?.componentName);
+        return optionsOrFn(span);
+      };
+      return this._tracer.startActiveSpan(name, {}, context.active(), wrappedFn2);
+    }
+    if (typeof ctxOrFn === "function") {
+      const wrappedFn2 = (span) => {
+        const currentBaggage = propagation.getBaggage(context.active());
+        span.setAttribute("componentName", currentBaggage?.componentName);
+        return ctxOrFn(span);
+      };
+      return this._tracer.startActiveSpan(name, optionsOrFn, context.active(), wrappedFn2);
+    }
+    const wrappedFn = (span) => {
+      const currentBaggage = propagation.getBaggage(ctxOrFn ?? context.active());
+      span.setAttribute("componentName", currentBaggage?.componentName);
+      return fn(span);
+    };
+    return this._tracer.startActiveSpan(name, optionsOrFn, ctxOrFn, wrappedFn);
+  }
+};
+
+export { InstrumentClass, OTLPTraceExporter, Telemetry, hasActiveTelemetry, withSpan };

package/dist/{chunk-DHCULRJM.js → chunk-J3W3IHDO.js}

@@ -1,31 +1,25 @@
-import { DefaultStorage } from './chunk-Z7JFMQZZ.js';
-import { InstrumentClass, Telemetry } from './chunk-4ZUSEHLH.js';
-import { LogLevel, createLogger, noopLogger } from './chunk-ICMEXHKD.js';
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
+import { InstrumentClass, OTLPTraceExporter, Telemetry } from './chunk-FGZVE4CM.js';
+import { DefaultStorage } from './chunk-U6J2FOU4.js';
+import { LogLevel, createLogger, noopLogger } from './chunk-O2VP5JBC.js';
+import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-C6A6W6XS.js';
 
 // src/mastra/index.ts
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata, "_ts_metadata");
-var _Mastra = class _Mastra {
+var _Mastra_decorators, _init;
+_Mastra_decorators = [InstrumentClass({
+  prefix: "mastra",
+  excludeMethods: ["getLogger", "getTelemetry"]
+})];
+var Mastra = class {
+  vectors;
+  agents;
+  logger;
+  workflows;
+  telemetry;
+  tts;
+  deployer;
+  storage;
+  memory;
   constructor(config) {
-    __publicField(this, "vectors");
-    __publicField(this, "agents");
-    __publicField(this, "logger");
-    __publicField(this, "workflows");
-    __publicField(this, "telemetry");
-    __publicField(this, "tts");
-    __publicField(this, "deployer");
-    __publicField(this, "storage");
-    __publicField(this, "memory");
     let logger;
     if (config?.logger === false) {
       logger = noopLogger;
@@ -34,42 +28,45 @@ var _Mastra = class _Mastra {
         logger = config.logger;
       } else {
         const levleOnEnv = process.env.NODE_ENV === "production" ? LogLevel.WARN : LogLevel.INFO;
-        logger = createLogger({
-          name: "Mastra",
-          level: levleOnEnv
-        });
+        logger = createLogger({ name: "Mastra", level: levleOnEnv });
       }
     }
     this.logger = logger;
-    if (config?.telemetry) {
-      this.telemetry = Telemetry.init(config.telemetry);
+    let storage = config?.storage;
+    if (!storage) {
+      storage = new DefaultStorage({
+        config: {
+          url: process.env.MASTRA_DEFAULT_STORAGE_URL || `:memory:`
+        }
+      });
+    }
+    if (storage instanceof DefaultStorage && config?.telemetry?.export?.type !== "custom") {
+      const newTelemetry = {
+        ...config?.telemetry || {},
+        export: {
+          type: "custom",
+          exporter: new OTLPTraceExporter({
+            logger: this.getLogger(),
+            storage
+          })
+        }
+      };
+      this.telemetry = Telemetry.init(newTelemetry);
+    } else if (config?.telemetry) {
+      this.telemetry = Telemetry.init(config?.telemetry);
     }
     if (config?.deployer) {
       this.deployer = config.deployer;
       if (this.telemetry) {
         this.deployer = this.telemetry.traceClass(config.deployer, {
-          excludeMethods: [
-            "__setTelemetry",
-            "__getTelemetry"
-          ]
+          excludeMethods: ["__setTelemetry", "__getTelemetry"]
         });
         this.deployer.__setTelemetry(this.telemetry);
       }
     }
-    let storage = config?.storage;
-    if (!storage) {
-      storage = new DefaultStorage({
-        config: {
-          url: ":memory:"
-        }
-      });
-    }
     if (this.telemetry) {
       this.storage = this.telemetry.traceClass(storage, {
-        excludeMethods: [
-          "__setTelemetry",
-          "__getTelemetry"
-        ]
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
       });
       this.storage.__setTelemetry(this.telemetry);
     } else {
@@ -80,10 +77,7 @@ var _Mastra = class _Mastra {
       Object.entries(config.vectors).forEach(([key, vector]) => {
         if (this.telemetry) {
           vectors[key] = this.telemetry.traceClass(vector, {
-            excludeMethods: [
-              "__setTelemetry",
-              "__getTelemetry"
-            ]
+            excludeMethods: ["__setTelemetry", "__getTelemetry"]
           });
           vectors[key].__setTelemetry(this.telemetry);
         } else {
@@ -99,10 +93,7 @@ var _Mastra = class _Mastra {
       this.memory = config.memory;
       if (this.telemetry) {
         this.memory = this.telemetry.traceClass(config.memory, {
-          excludeMethods: [
-            "__setTelemetry",
-            "__getTelemetry"
-          ]
+          excludeMethods: ["__setTelemetry", "__getTelemetry"]
         });
         this.memory.__setTelemetry(this.telemetry);
       }
@@ -113,10 +104,7 @@ var _Mastra = class _Mastra {
         if (this.tts?.[key]) {
           if (this.telemetry) {
             this.tts[key] = this.telemetry.traceClass(ttsCl, {
-              excludeMethods: [
-                "__setTelemetry",
-                "__getTelemetry"
-              ]
+              excludeMethods: ["__setTelemetry", "__getTelemetry"]
             });
             this.tts[key].__setTelemetry(this.telemetry);
           }
@@ -157,9 +145,7 @@ var _Mastra = class _Mastra {
         this.workflows[key] = workflow;
       });
     }
-    this.setLogger({
-      logger
-    });
+    this.setLogger({ logger });
   }
   getAgent(name) {
     const agent = this.agents?.[name];
@@ -190,9 +176,7 @@ var _Mastra = class _Mastra {
       throw new Error(`Workflow with ID ${String(id)} not found`);
     }
     if (serialized) {
-      return {
-        name: workflow.name
-      };
+      return { name: workflow.name };
     }
     return workflow;
   }
@@ -201,15 +185,13 @@ var _Mastra = class _Mastra {
       return Object.entries(this.workflows).reduce((acc, [k, v]) => {
         return {
           ...acc,
-          [k]: {
-            name: v.name
-          }
+          [k]: { name: v.name }
         };
       }, {});
     }
     return this.workflows;
   }
-  setStorage({ storage }) {
+  setStorage(storage) {
     this.storage = storage;
   }
   setLogger({ logger }) {
@@ -244,6 +226,65 @@ var _Mastra = class _Mastra {
       });
     }
   }
+  setTelemetry(telemetry) {
+    this.telemetry = Telemetry.init(telemetry);
+    if (this.agents) {
+      Object.keys(this.agents).forEach((key) => {
+        if (this.telemetry) {
+          this.agents?.[key]?.__setTelemetry(this.telemetry);
+        }
+      });
+    }
+    if (this.workflows) {
+      Object.keys(this.workflows).forEach((key) => {
+        if (this.telemetry) {
+          this.workflows?.[key]?.__setTelemetry(this.telemetry);
+        }
+      });
+    }
+    if (this.memory) {
+      this.memory = this.telemetry.traceClass(this.memory, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.memory.__setTelemetry(this.telemetry);
+    }
+    if (this.deployer) {
+      this.deployer = this.telemetry.traceClass(this.deployer, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.deployer.__setTelemetry(this.telemetry);
+    }
+    if (this.tts) {
+      let tts = {};
+      Object.entries(this.tts).forEach(([key, ttsCl]) => {
+        if (this.telemetry) {
+          tts[key] = this.telemetry.traceClass(ttsCl, {
+            excludeMethods: ["__setTelemetry", "__getTelemetry"]
+          });
+          tts[key].__setTelemetry(this.telemetry);
+        }
+      });
+      this.tts = tts;
+    }
+    if (this.storage) {
+      this.storage = this.telemetry.traceClass(this.storage, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.storage.__setTelemetry(this.telemetry);
+    }
+    if (this.vectors) {
+      let vectors = {};
+      Object.entries(this.vectors).forEach(([key, vector]) => {
+        if (this.telemetry) {
+          vectors[key] = this.telemetry.traceClass(vector, {
+            excludeMethods: ["__setTelemetry", "__getTelemetry"]
+          });
+          vectors[key].__setTelemetry(this.telemetry);
+        }
+      });
+      this.vectors = vectors;
+    }
+  }
   getLogger() {
     return this.logger;
   }
@@ -254,10 +295,7 @@ var _Mastra = class _Mastra {
     if (!transportId) {
       throw new Error("Transport ID is required");
     }
-    return await this.logger.getLogsByRunId({
-      runId,
-      transportId
-    });
+    return await this.logger.getLogsByRunId({ runId, transportId });
   }
   async getLogs(transportId) {
     if (!transportId) {
@@ -266,20 +304,8 @@ var _Mastra = class _Mastra {
     return await this.logger.getLogs(transportId);
   }
 };
-__name(_Mastra, "Mastra");
-var Mastra = _Mastra;
-Mastra = _ts_decorate([
-  InstrumentClass({
-    prefix: "mastra",
-    excludeMethods: [
-      "getLogger",
-      "getTelemetry"
-    ]
-  }),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    Object
-  ])
-], Mastra);
+_init = __decoratorStart(null);
+Mastra = __decorateElement(_init, 0, "Mastra", _Mastra_decorators, Mastra);
+__runInitializers(_init, 1, Mastra);
 
 export { Mastra };

package/dist/chunk-K36NSQWH.js

@@ -0,0 +1,10 @@
+import { MastraBundler } from './chunk-22LC46YN.js';
+
+// src/deployer/index.ts
+var MastraDeployer = class extends MastraBundler {
+  constructor({ name }) {
+    super({ component: "DEPLOYER", name });
+  }
+};
+
+export { MastraDeployer };