@mastra/observability 0.0.0-safe-stringify-telemetry-20251205024938 → 0.0.0-scorers-logs-20251208093427

package/dist/config.d.ts

@@ -0,0 +1,445 @@
+/**
+ * Configuration types for Mastra Observability
+ *
+ * These types define the configuration structure for observability,
+ * including tracing configs, sampling strategies, and registry setup.
+ */
+import type { RequestContext } from '@mastra/core/di';
+import type { ObservabilityInstance, ObservabilityExporter, ObservabilityBridge, SpanOutputProcessor, ConfigSelector } from '@mastra/core/observability';
+import { z } from 'zod';
+/**
+ * Sampling strategy types
+ */
+export declare enum SamplingStrategyType {
+    ALWAYS = "always",
+    NEVER = "never",
+    RATIO = "ratio",
+    CUSTOM = "custom"
+}
+/**
+ * Options passed when using a custom sampler strategy
+ */
+export interface CustomSamplerOptions {
+    requestContext?: RequestContext;
+    metadata?: Record<string, any>;
+}
+/**
+ * Sampling strategy configuration
+ */
+export type SamplingStrategy = {
+    type: SamplingStrategyType.ALWAYS;
+} | {
+    type: SamplingStrategyType.NEVER;
+} | {
+    type: SamplingStrategyType.RATIO;
+    probability: number;
+} | {
+    type: SamplingStrategyType.CUSTOM;
+    sampler: (options?: CustomSamplerOptions) => boolean;
+};
+/**
+ * Configuration for a single observability instance
+ */
+export interface ObservabilityInstanceConfig {
+    /** Unique identifier for this config in the tracing registry */
+    name: string;
+    /** Service name for tracing */
+    serviceName: string;
+    /** Sampling strategy - controls whether tracing is collected (defaults to ALWAYS) */
+    sampling?: SamplingStrategy;
+    /** Custom exporters */
+    exporters?: ObservabilityExporter[];
+    /** Observability bridge (e.g., OpenTelemetry bridge for context extraction) */
+    bridge?: ObservabilityBridge;
+    /** Custom span output processors */
+    spanOutputProcessors?: SpanOutputProcessor[];
+    /** Set to `true` if you want to see spans internal to the operation of mastra */
+    includeInternalSpans?: boolean;
+    /**
+     * RequestContext keys to automatically extract as metadata for all spans
+     * created with this tracing configuration.
+     * Supports dot notation for nested values.
+     */
+    requestContextKeys?: string[];
+}
+/**
+ * Complete Observability registry configuration
+ */
+export interface ObservabilityRegistryConfig {
+    /** Enables default exporters, with sampling: always, and sensitive data filtering */
+    default?: {
+        enabled?: boolean;
+    };
+    /** Map of tracing instance names to their configurations or pre-instantiated instances */
+    configs?: Record<string, Omit<ObservabilityInstanceConfig, 'name'> | ObservabilityInstance>;
+    /** Optional selector function to choose which tracing instance to use */
+    configSelector?: ConfigSelector;
+}
+/**
+ * Zod schema for SamplingStrategy
+ */
+export declare const samplingStrategySchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<SamplingStrategyType.ALWAYS>;
+}, "strip", z.ZodTypeAny, {
+    type: SamplingStrategyType.ALWAYS;
+}, {
+    type: SamplingStrategyType.ALWAYS;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<SamplingStrategyType.NEVER>;
+}, "strip", z.ZodTypeAny, {
+    type: SamplingStrategyType.NEVER;
+}, {
+    type: SamplingStrategyType.NEVER;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<SamplingStrategyType.RATIO>;
+    probability: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: SamplingStrategyType.RATIO;
+    probability: number;
+}, {
+    type: SamplingStrategyType.RATIO;
+    probability: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<SamplingStrategyType.CUSTOM>;
+    sampler: z.ZodFunction<z.ZodTuple<[z.ZodOptional<z.ZodAny>], z.ZodUnknown>, z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: SamplingStrategyType.CUSTOM;
+    sampler: (args_0: any, ...args: unknown[]) => boolean;
+}, {
+    type: SamplingStrategyType.CUSTOM;
+    sampler: (args_0: any, ...args: unknown[]) => boolean;
+}>]>;
+/**
+ * Zod schema for ObservabilityInstanceConfig
+ * Note: exporters, spanOutputProcessors, bridge, and configSelector are validated as any
+ * since they're complex runtime objects
+ */
+export declare const observabilityInstanceConfigSchema: z.ZodEffects<z.ZodObject<{
+    name: z.ZodString;
+    serviceName: z.ZodString;
+    sampling: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<SamplingStrategyType.ALWAYS>;
+    }, "strip", z.ZodTypeAny, {
+        type: SamplingStrategyType.ALWAYS;
+    }, {
+        type: SamplingStrategyType.ALWAYS;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<SamplingStrategyType.NEVER>;
+    }, "strip", z.ZodTypeAny, {
+        type: SamplingStrategyType.NEVER;
+    }, {
+        type: SamplingStrategyType.NEVER;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<SamplingStrategyType.RATIO>;
+        probability: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    }, {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<SamplingStrategyType.CUSTOM>;
+        sampler: z.ZodFunction<z.ZodTuple<[z.ZodOptional<z.ZodAny>], z.ZodUnknown>, z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    }, {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    }>]>>;
+    exporters: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    bridge: z.ZodOptional<z.ZodAny>;
+    spanOutputProcessors: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    includeInternalSpans: z.ZodOptional<z.ZodBoolean>;
+    requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    serviceName: string;
+    sampling?: {
+        type: SamplingStrategyType.ALWAYS;
+    } | {
+        type: SamplingStrategyType.NEVER;
+    } | {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    } | {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    } | undefined;
+    exporters?: any[] | undefined;
+    bridge?: any;
+    spanOutputProcessors?: any[] | undefined;
+    includeInternalSpans?: boolean | undefined;
+    requestContextKeys?: string[] | undefined;
+}, {
+    name: string;
+    serviceName: string;
+    sampling?: {
+        type: SamplingStrategyType.ALWAYS;
+    } | {
+        type: SamplingStrategyType.NEVER;
+    } | {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    } | {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    } | undefined;
+    exporters?: any[] | undefined;
+    bridge?: any;
+    spanOutputProcessors?: any[] | undefined;
+    includeInternalSpans?: boolean | undefined;
+    requestContextKeys?: string[] | undefined;
+}>, {
+    name: string;
+    serviceName: string;
+    sampling?: {
+        type: SamplingStrategyType.ALWAYS;
+    } | {
+        type: SamplingStrategyType.NEVER;
+    } | {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    } | {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    } | undefined;
+    exporters?: any[] | undefined;
+    bridge?: any;
+    spanOutputProcessors?: any[] | undefined;
+    includeInternalSpans?: boolean | undefined;
+    requestContextKeys?: string[] | undefined;
+}, {
+    name: string;
+    serviceName: string;
+    sampling?: {
+        type: SamplingStrategyType.ALWAYS;
+    } | {
+        type: SamplingStrategyType.NEVER;
+    } | {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    } | {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    } | undefined;
+    exporters?: any[] | undefined;
+    bridge?: any;
+    spanOutputProcessors?: any[] | undefined;
+    includeInternalSpans?: boolean | undefined;
+    requestContextKeys?: string[] | undefined;
+}>;
+/**
+ * Zod schema for config values in the configs map
+ * This is the config object without the name field
+ */
+export declare const observabilityConfigValueSchema: z.ZodEffects<z.ZodObject<{
+    serviceName: z.ZodString;
+    sampling: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<SamplingStrategyType.ALWAYS>;
+    }, "strip", z.ZodTypeAny, {
+        type: SamplingStrategyType.ALWAYS;
+    }, {
+        type: SamplingStrategyType.ALWAYS;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<SamplingStrategyType.NEVER>;
+    }, "strip", z.ZodTypeAny, {
+        type: SamplingStrategyType.NEVER;
+    }, {
+        type: SamplingStrategyType.NEVER;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<SamplingStrategyType.RATIO>;
+        probability: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    }, {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<SamplingStrategyType.CUSTOM>;
+        sampler: z.ZodFunction<z.ZodTuple<[z.ZodOptional<z.ZodAny>], z.ZodUnknown>, z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    }, {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    }>]>>;
+    exporters: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    bridge: z.ZodOptional<z.ZodAny>;
+    spanOutputProcessors: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    includeInternalSpans: z.ZodOptional<z.ZodBoolean>;
+    requestContextKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    serviceName: string;
+    sampling?: {
+        type: SamplingStrategyType.ALWAYS;
+    } | {
+        type: SamplingStrategyType.NEVER;
+    } | {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    } | {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    } | undefined;
+    exporters?: any[] | undefined;
+    bridge?: any;
+    spanOutputProcessors?: any[] | undefined;
+    includeInternalSpans?: boolean | undefined;
+    requestContextKeys?: string[] | undefined;
+}, {
+    serviceName: string;
+    sampling?: {
+        type: SamplingStrategyType.ALWAYS;
+    } | {
+        type: SamplingStrategyType.NEVER;
+    } | {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    } | {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    } | undefined;
+    exporters?: any[] | undefined;
+    bridge?: any;
+    spanOutputProcessors?: any[] | undefined;
+    includeInternalSpans?: boolean | undefined;
+    requestContextKeys?: string[] | undefined;
+}>, {
+    serviceName: string;
+    sampling?: {
+        type: SamplingStrategyType.ALWAYS;
+    } | {
+        type: SamplingStrategyType.NEVER;
+    } | {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    } | {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    } | undefined;
+    exporters?: any[] | undefined;
+    bridge?: any;
+    spanOutputProcessors?: any[] | undefined;
+    includeInternalSpans?: boolean | undefined;
+    requestContextKeys?: string[] | undefined;
+}, {
+    serviceName: string;
+    sampling?: {
+        type: SamplingStrategyType.ALWAYS;
+    } | {
+        type: SamplingStrategyType.NEVER;
+    } | {
+        type: SamplingStrategyType.RATIO;
+        probability: number;
+    } | {
+        type: SamplingStrategyType.CUSTOM;
+        sampler: (args_0: any, ...args: unknown[]) => boolean;
+    } | undefined;
+    exporters?: any[] | undefined;
+    bridge?: any;
+    spanOutputProcessors?: any[] | undefined;
+    includeInternalSpans?: boolean | undefined;
+    requestContextKeys?: string[] | undefined;
+}>;
+/**
+ * Zod schema for ObservabilityRegistryConfig
+ * Note: Individual configs are validated separately in the constructor to allow for
+ * both plain config objects and pre-instantiated ObservabilityInstance objects.
+ * The schema is permissive to handle edge cases gracefully (arrays, null values).
+ */
+export declare const observabilityRegistryConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    default: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    configs: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>>;
+    configSelector: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    default: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    configs: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>>;
+    configSelector: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    default: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    configs: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>>;
+    configSelector: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+    default: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    configs: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>>;
+    configSelector: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    default: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    configs: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>>;
+    configSelector: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+    default: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    configs: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>>;
+    configSelector: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    default: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    configs: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>>;
+    configSelector: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+    default: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    configs: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>>;
+    configSelector: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    default: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>;
+    configs: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodAny>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>>;
+    configSelector: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACf,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,oBAAY,oBAAoB;IAC9B,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,KAAK,UAAU;IACf,MAAM,WAAW;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,oBAAoB,CAAC,KAAK,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,oBAAoB,CAAC,MAAM,CAAC;IAAC,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAA;CAAE,CAAC;AAMhG;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,uBAAuB;IACvB,SAAS,CAAC,EAAE,qBAAqB,EAAE,CAAC;IACpC,+EAA+E;IAC/E,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,oCAAoC;IACpC,oBAAoB,CAAC,EAAE,mBAAmB,EAAE,CAAC;IAC7C,iFAAiF;IACjF,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,qFAAqF;IACrF,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;IACF,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,2BAA2B,EAAE,MAAM,CAAC,GAAG,qBAAqB,CAAC,CAAC;IAC5F,yEAAyE;IACzE,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAMD;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAejC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqB3C,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBxC,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAqE3C,CAAC"}

package/dist/default.d.ts

@@ -0,0 +1,29 @@
+import type { Mastra } from '@mastra/core';
+import { MastraBase } from '@mastra/core/base';
+import type { IMastraLogger } from '@mastra/core/logger';
+import type { ConfigSelector, ConfigSelectorOptions, ObservabilityEntrypoint, ObservabilityInstance } from '@mastra/core/observability';
+import type { ObservabilityRegistryConfig } from './config.js';
+export declare class Observability extends MastraBase implements ObservabilityEntrypoint {
+    #private;
+    constructor(config: ObservabilityRegistryConfig);
+    setMastraContext(options: {
+        mastra: Mastra;
+    }): void;
+    setLogger(options: {
+        logger: IMastraLogger;
+    }): void;
+    getSelectedInstance(options: ConfigSelectorOptions): ObservabilityInstance | undefined;
+    /**
+     * Registry management methods
+     */
+    registerInstance(name: string, instance: ObservabilityInstance, isDefault?: boolean): void;
+    getInstance(name: string): ObservabilityInstance | undefined;
+    getDefaultInstance(): ObservabilityInstance | undefined;
+    listInstances(): ReadonlyMap<string, ObservabilityInstance>;
+    unregisterInstance(name: string): boolean;
+    hasInstance(name: string): boolean;
+    setConfigSelector(selector: ConfigSelector): void;
+    clear(): void;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=default.d.ts.map

package/dist/default.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.d.ts","sourceRoot":"","sources":["../src/default.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAG/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAA+B,2BAA2B,EAAE,MAAM,UAAU,CAAC;AAezF,qBAAa,aAAc,SAAQ,UAAW,YAAW,uBAAuB;;gBAGlE,MAAM,EAAE,2BAA2B;IAsF/C,gBAAgB,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAuBnD,SAAS,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,aAAa,CAAA;KAAE,GAAG,IAAI;IAOnD,mBAAmB,CAAC,OAAO,EAAE,qBAAqB,GAAG,qBAAqB,GAAG,SAAS;IAItF;;OAEG;IAEH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,qBAAqB,EAAE,SAAS,UAAQ,GAAG,IAAI;IAIxF,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS;IAI5D,kBAAkB,IAAI,qBAAqB,GAAG,SAAS;IAIvD,aAAa,IAAI,WAAW,CAAC,MAAM,EAAE,qBAAqB,CAAC;IAI3D,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIzC,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIlC,iBAAiB,CAAC,QAAQ,EAAE,cAAc,GAAG,IAAI;IAIjD,KAAK,IAAI,IAAI;IAIP,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}

package/dist/exporters/base.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Base Exporter for Observability
+ *
+ * Provides common functionality shared by all observability exporters:
+ * - Logger initialization with proper Mastra logger support
+ * - Disabled state management
+ * - Graceful shutdown lifecycle
+ */
+import { LogLevel } from '@mastra/core/logger';
+import type { IMastraLogger } from '@mastra/core/logger';
+import type { TracingEvent, ObservabilityExporter, InitExporterOptions } from '@mastra/core/observability';
+/**
+ * Base configuration that all exporters should support
+ */
+export interface BaseExporterConfig {
+    /** Optional Mastra logger instance */
+    logger?: IMastraLogger;
+    /** Log level for the exporter (defaults to INFO) - accepts both enum and string */
+    logLevel?: LogLevel | 'debug' | 'info' | 'warn' | 'error';
+}
+/**
+ * Abstract base class for observability exporters
+ *
+ * Handles common concerns:
+ * - Logger setup with proper Mastra logger
+ * - Disabled state management
+ * - Basic lifecycle methods
+ *
+ * @example
+ * ```typescript
+ * class MyExporter extends BaseExporter {
+ *   name = 'my-exporter';
+ *
+ *   constructor(config: MyExporterConfig) {
+ *     super(config);
+ *
+ *     if (!config.apiKey) {
+ *       this.setDisabled('Missing API key');
+ *       return;
+ *     }
+ *
+ *     // Initialize exporter-specific logic
+ *   }
+ *
+ *   async _exportEvent(event: TracingEvent): Promise<void> {
+ *     // Export logic
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class BaseExporter implements ObservabilityExporter {
+    /** Exporter name - must be implemented by subclasses */
+    abstract name: string;
+    /** Mastra logger instance */
+    protected logger: IMastraLogger;
+    /** Whether this exporter is disabled */
+    protected isDisabled: boolean;
+    /**
+     * Initialize the base exporter with logger
+     */
+    constructor(config?: BaseExporterConfig);
+    /**
+     * Set the logger for the exporter (called by Mastra/ObservabilityInstance during initialization)
+     */
+    __setLogger(logger: IMastraLogger): void;
+    /**
+     * Convert string log level to LogLevel enum
+     */
+    private resolveLogLevel;
+    /**
+     * Mark the exporter as disabled and log a message
+     *
+     * @param reason - Reason why the exporter is disabled
+     */
+    protected setDisabled(reason: string): void;
+    /**
+     * Export a tracing event
+     *
+     * This method checks if the exporter is disabled before calling _exportEvent.
+     * Subclasses should implement _exportEvent instead of overriding this method.
+     */
+    exportTracingEvent(event: TracingEvent): Promise<void>;
+    /**
+     * Export a tracing event - must be implemented by subclasses
+     *
+     * This method is called by exportTracingEvent after checking if the exporter is disabled.
+     */
+    protected abstract _exportTracingEvent(event: TracingEvent): Promise<void>;
+    /**
+     * Optional initialization hook called after Mastra is fully configured
+     */
+    init?(_options: InitExporterOptions): void;
+    /**
+     * Optional method to add scores to traces
+     */
+    addScoreToTrace?(_args: {
+        traceId: string;
+        spanId?: string;
+        score: number;
+        reason?: string;
+        scorerName: string;
+        metadata?: Record<string, any>;
+    }): Promise<void>;
+    /**
+     * Shutdown the exporter and clean up resources
+     *
+     * Default implementation just logs. Override to add custom cleanup.
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/exporters/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/exporters/base.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAiB,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAE3G;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,sCAAsC;IACtC,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,mFAAmF;IACnF,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;CAC3D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,8BAAsB,YAAa,YAAW,qBAAqB;IACjE,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,6BAA6B;IAC7B,SAAS,CAAC,MAAM,EAAE,aAAa,CAAC;IAEhC,wCAAwC;IACxC,SAAS,CAAC,UAAU,EAAE,OAAO,CAAS;IAEtC;;OAEG;gBACS,MAAM,GAAE,kBAAuB;IAO3C;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAMxC;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB;;;;OAIG;IACH,SAAS,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK3C;;;;;OAKG;IACG,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5D;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAE1E;;OAEG;IACH,IAAI,CAAC,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI;IAE1C;;OAEG;IACH,eAAe,CAAC,CAAC,KAAK,EAAE;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KAChC,GAAG,OAAO,CAAC,IAAI,CAAC;IAEjB;;;;OAIG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}

package/dist/exporters/cloud.d.ts

@@ -0,0 +1,30 @@
+import type { TracingEvent } from '@mastra/core/observability';
+import { BaseExporter } from './base.js';
+import type { BaseExporterConfig } from './base.js';
+export interface CloudExporterConfig extends BaseExporterConfig {
+    maxBatchSize?: number;
+    maxBatchWaitMs?: number;
+    maxRetries?: number;
+    accessToken?: string;
+    endpoint?: string;
+}
+export declare class CloudExporter extends BaseExporter {
+    name: string;
+    private config;
+    private buffer;
+    private flushTimer;
+    constructor(config?: CloudExporterConfig);
+    protected _exportTracingEvent(event: TracingEvent): Promise<void>;
+    private addToBuffer;
+    private formatSpan;
+    private shouldFlush;
+    private scheduleFlush;
+    private flush;
+    /**
+     * Uploads spans to cloud API using fetchWithRetry for all retry logic
+     */
+    private batchUpload;
+    private resetBuffer;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=cloud.d.ts.map

package/dist/exporters/cloud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud.d.ts","sourceRoot":"","sources":["../../src/exporters/cloud.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,4BAA4B,CAAC;AAEhF,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAEjD,MAAM,WAAW,mBAAoB,SAAQ,kBAAkB;IAC7D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AA0BD,qBAAa,aAAc,SAAQ,YAAY;IAC7C,IAAI,SAAyC;IAE7C,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,UAAU,CAA+B;gBAErC,MAAM,GAAE,mBAAwB;cA8B5B,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBvE,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,UAAU;IAsBlB,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,aAAa;YAoBP,KAAK;IA8CnB;;OAEG;YACW,WAAW;IAezB,OAAO,CAAC,WAAW;IAMb,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAuChC"}

package/dist/exporters/console.d.ts

@@ -0,0 +1,10 @@
+import type { TracingEvent } from '@mastra/core/observability';
+import { BaseExporter } from './base.js';
+import type { BaseExporterConfig } from './base.js';
+export declare class ConsoleExporter extends BaseExporter {
+    name: string;
+    constructor(config?: BaseExporterConfig);
+    protected _exportTracingEvent(event: TracingEvent): Promise<void>;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=console.d.ts.map

package/dist/exporters/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../src/exporters/console.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAEjD,qBAAa,eAAgB,SAAQ,YAAY;IAC/C,IAAI,SAA8B;gBAEtB,MAAM,GAAE,kBAAuB;cAI3B,mBAAmB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IA+EjE,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAGhC"}