@mastra/observability 0.0.0-sidebar-window-undefined-fix-20251029233656 → 0.0.0-testing-cloud-studios-20260114234039

package/README.md

@@ -0,0 +1,54 @@
+# Mastra Observability
+
+Tracing and monitoring for AI operations in Mastra.
+
+## Installation
+
+```bash
+npm install @mastra/observability
+```
+
+## Quick Start
+
+```typescript
+import { Mastra } from '@mastra/core';
+import { Observability, DefaultExporter, CloudExporter, SensitiveDataFilter } from '@mastra/observability';
+
+export const mastra = new Mastra({
+  observability: new Observability({
+    configs: {
+      default: {
+        serviceName: 'my-app',
+        exporters: [
+          new DefaultExporter(), // Persists traces for Mastra Studio
+          new CloudExporter(), // Sends to Mastra Cloud
+        ],
+        spanOutputProcessors: [new SensitiveDataFilter()],
+      },
+    },
+  }),
+});
+```
+
+## Features
+
+- **Auto-instrumentation** - Traces agent runs, LLM calls, tool executions, and workflows
+- **Pluggable Exporters** - Exporters for Studio and Cloud, plus integrations for Arize, Braintrust, Langfuse, LangSmith, and OpenTelemetry
+- **Sampling Strategies** - Always, ratio-based, or custom sampling
+- **Span Processors** - Transform or filter span data before export
+- **OpenTelemetry Compatible** - Standard trace/span ID formats for integration
+
+## Span Types
+
+- `WORKFLOW_RUN` - Workflow execution
+- `WORKFLOW_STEP` - Individual workflow step
+- `AGENT_RUN` - Agent processing
+- `MODEL_GENERATION` - LLM API calls
+- `TOOL_CALL` - Tool execution
+- `MCP_TOOL_CALL` - MCP tool execution
+- `PROCESSOR_RUN` - Processor execution
+- `GENERIC` - Custom operations
+
+## Documentation
+
+For configuration options, exporters, sampling strategies, and more, see the [full documentation](https://mastra.ai/docs/v1/observability/overview).

package/dist/config.d.ts

@@ -0,0 +1,553 @@
+/**
+ * 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, SerializationOptions } 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[];
+    /**
+     * Options for controlling serialization of span data (input/output/attributes).
+     * Use these to customize truncation limits for large payloads.
+     */
+    serializationOptions?: SerializationOptions;
+}
+/**
+ * Complete Observability registry configuration
+ */
+export interface ObservabilityRegistryConfig {
+    /**
+     * Enables default exporters, with sampling: always, and sensitive data filtering
+     * @deprecated Use explicit `configs` with DefaultExporter, CloudExporter, and SensitiveDataFilter instead.
+     * This option will be removed in a future version.
+     */
+    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 SerializationOptions
+ */
+export declare const serializationOptionsSchema: z.ZodOptional<z.ZodObject<{
+    maxStringLength: z.ZodOptional<z.ZodNumber>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    maxArrayLength: z.ZodOptional<z.ZodNumber>;
+    maxObjectKeys: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxStringLength?: number | undefined;
+    maxDepth?: number | undefined;
+    maxArrayLength?: number | undefined;
+    maxObjectKeys?: number | undefined;
+}, {
+    maxStringLength?: number | undefined;
+    maxDepth?: number | undefined;
+    maxArrayLength?: number | undefined;
+    maxObjectKeys?: number | undefined;
+}>>;
+/**
+ * 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">>;
+    serializationOptions: z.ZodOptional<z.ZodObject<{
+        maxStringLength: z.ZodOptional<z.ZodNumber>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+        maxArrayLength: z.ZodOptional<z.ZodNumber>;
+        maxObjectKeys: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    }, {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    }>>;
+}, "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;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | 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;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | 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;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | 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;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | 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">>;
+    serializationOptions: z.ZodOptional<z.ZodObject<{
+        maxStringLength: z.ZodOptional<z.ZodNumber>;
+        maxDepth: z.ZodOptional<z.ZodNumber>;
+        maxArrayLength: z.ZodOptional<z.ZodNumber>;
+        maxObjectKeys: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    }, {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    }>>;
+}, "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;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | 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;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | 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;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | 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;
+    serializationOptions?: {
+        maxStringLength?: number | undefined;
+        maxDepth?: number | undefined;
+        maxArrayLength?: number | undefined;
+        maxObjectKeys?: number | undefined;
+    } | 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":"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"}

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;IA4F/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"}