@mastra/mcp-docs-server 0.13.39 → 1.0.0-beta.0

package/.docs/raw/observability/{ai-tracing → tracing}/overview.mdx

@@ -1,33 +1,37 @@
 ---
-title: "AI Tracing | Observability | Mastra Docs"
-description: "Set up AI tracing for Mastra applications"
+title: "Tracing | Observability | Mastra Docs"
+description: "Set up Tracing for Mastra applications"
 ---
 
-# AI Tracing
+# Tracing
 
-AI Tracing provides specialized monitoring and debugging for the AI-related operations in your application. When enabled, Mastra automatically creates traces for agent runs, LLM generations, tool calls, and workflow steps with AI-specific context and metadata.
+Tracing provides specialized monitoring and debugging for the AI-related operations in your application. When enabled, Mastra automatically creates traces for agent runs, LLM generations, tool calls, and workflow steps with AI-specific context and metadata.
 
-Unlike traditional application tracing, AI Tracing focuses specifically on understanding your AI pipeline — capturing token usage, model parameters, tool execution details, and conversation flows. This makes it easier to debug issues, optimize performance, and understand how your AI systems behave in production.
+Unlike traditional application tracing, Tracing focuses specifically on understanding your AI pipeline — capturing token usage, model parameters, tool execution details, and conversation flows. This makes it easier to debug issues, optimize performance, and understand how your AI systems behave in production.
 
 ## How It Works
 
-AI Traces are created by:
+Traces are created by:
 
 - **Configure exporters** → send trace data to observability platforms
 - **Set sampling strategies** → control which traces are collected
-- **Run agents and workflows** → Mastra auto-instruments them with AI Tracing
+- **Run agents and workflows** → Mastra auto-instruments them with Tracing
 
 ## Configuration
 
 ### Basic Config
 
 ```ts title="src/mastra/index.ts" showLineNumbers copy
+import { Mastra } from "@mastra/core";
+import { Observability } from "@mastra/observability";
+
 export const mastra = new Mastra({
   // ... other config
-  observability: {
+  observability: new Observability({
     default: { enabled: true }, // Enables DefaultExporter and CloudExporter
-  },
+  }),
   storage: new LibSQLStore({
+    id: 'mastra-storage',
     url: "file:./mastra.db", // Storage is required for tracing
   }),
 });
@@ -40,7 +44,7 @@ When enabled, the default configuration automatically includes:
 - **Exporters**:
   - `DefaultExporter` - Persists traces to your configured storage
   - `CloudExporter` - Sends traces to Mastra Cloud (requires `MASTRA_CLOUD_ACCESS_TOKEN`)
-- **Processors**: `SensitiveDataFilter` - Automatically redacts sensitive fields
+- **Span Output Processors**: `SensitiveDataFilter` - Automatically redacts sensitive fields
 
 ### Expanded Basic Config
 
@@ -48,24 +52,26 @@ This default configuration is a minimal helper that equates to this more verbose
 
 ```ts title="src/mastra/index.ts" showLineNumbers copy
 import {
+  Observability,
   CloudExporter,
   DefaultExporter,
   SensitiveDataFilter,
-} from "@mastra/core/ai-tracing";
+} from "@mastra/observability";
 
 export const mastra = new Mastra({
   // ... other config
-  observability: {
+  observability: new Observability({
     configs: {
       default: {
         serviceName: "mastra",
         sampling: { type: "always" },
-        processors: [new SensitiveDataFilter()],
+        spanOutputProcessors: [new SensitiveDataFilter()],
         exporters: [new CloudExporter(), new DefaultExporter()],
       },
     },
-  },
+  }),
   storage: new LibSQLStore({
+    id: 'mastra-storage',
     url: "file:./mastra.db", // Storage is required for tracing
   }),
 });
@@ -73,24 +79,24 @@ export const mastra = new Mastra({
 
 ## Exporters
 
-Exporters determine where your AI trace data is sent and how it's stored. Choosing the right exporters allows you to integrate with your existing observability stack, comply with data residency requirements, and optimize for cost and performance. You can use multiple exporters simultaneously to send the same trace data to different destinations — for example, storing detailed traces locally for debugging while sending sampled data to a cloud provider for production monitoring.
+Exporters determine where your trace data is sent and how it's stored. Choosing the right exporters allows you to integrate with your existing observability stack, comply with data residency requirements, and optimize for cost and performance. You can use multiple exporters simultaneously to send the same trace data to different destinations — for example, storing detailed traces locally for debugging while sending sampled data to a cloud provider for production monitoring.
 
 ### Internal Exporters
 
 Mastra provides two built-in exporters that work out of the box:
 
-- **[Default](/docs/observability/ai-tracing/exporters/default)** - Persists traces to local storage for viewing in Studio
-- **[Cloud](/docs/observability/ai-tracing/exporters/cloud)** - Sends traces to Mastra Cloud for production monitoring and collaboration
+- **[Default]/docs/v1/observability/tracing/exporters/default)** - Persists traces to local storage for viewing in Studio
+- **[Cloud]/docs/v1/observability/tracing/exporters/cloud)** - Sends traces to Mastra Cloud for production monitoring and collaboration
 
 ### External Exporters
 
 In addition to the internal exporters, Mastra supports integration with popular observability platforms. These exporters allow you to leverage your existing monitoring infrastructure and take advantage of platform-specific features like alerting, dashboards, and correlation with other application metrics.
 
-- **[Arize](/docs/observability/ai-tracing/exporters/arize)** - Exports traces to Arize Phoenix or Arize AX using OpenInference semantic conventions
-- **[Braintrust](/docs/observability/ai-tracing/exporters/braintrust)** - Exports traces to Braintrust's eval and observability platform
-- **[Langfuse](/docs/observability/ai-tracing/exporters/langfuse)** - Sends traces to the Langfuse open-source LLM engineering platform
-- **[LangSmith](/docs/observability/ai-tracing/exporters/langsmith)** - Pushes traces into LangSmith's observability and evaluation toolkit
-- **[OpenTelemetry](/docs/observability/ai-tracing/exporters/otel)** - Deliver traces to any OpenTelemetry-compatible observability system
+- **[Arize]/docs/v1/observability/tracing/exporters/arize)** - Exports traces to Arize Phoenix or Arize AX using OpenInference semantic conventions
+- **[Braintrust]/docs/v1/observability/tracing/exporters/braintrust)** - Exports traces to Braintrust's eval and observability platform
+- **[Langfuse]/docs/v1/observability/tracing/exporters/langfuse)** - Sends traces to the Langfuse open-source LLM engineering platform
+- **[LangSmith]/docs/v1/observability/tracing/exporters/langsmith)** - Pushes traces into LangSmith's observability and evaluation toolkit
+- **[OpenTelemetry]/docs/v1/observability/tracing/exporters/otel)** - Deliver traces to any OpenTelemetry-compatible observability system
   - Supports: Dash0, Laminar, New Relic, SigNoz, Traceloop, Zipkin, and others!
 
 ## Sampling Strategies
@@ -132,7 +138,7 @@ sampling: {
 
 ### Custom Sampling
 
-Implements your own sampling logic based on runtime context, metadata, or business rules. Perfect for complex scenarios like sampling based on user tier, request type, or error conditions.
+Implements your own sampling logic based on request context, metadata, or business rules. Perfect for complex scenarios like sampling based on user tier, request type, or error conditions.
 
 ```ts
 sampling: {
@@ -153,7 +159,7 @@ sampling: {
 
 ```ts title="src/mastra/index.ts" showLineNumbers copy
 export const mastra = new Mastra({
-  observability: {
+  observability: new Observability({
     configs: {
       "10_percent": {
         serviceName: "my-service",
@@ -165,7 +171,7 @@ export const mastra = new Mastra({
         exporters: [new DefaultExporter()],
       },
     },
-  },
+  }),
 });
 ```
 
@@ -189,11 +195,11 @@ Note that only a single config can be used for a specific execution. But a singl
 
 ### Dynamic Configuration Selection
 
-Use `configSelector` to choose the appropriate tracing configuration based on runtime context:
+Use `configSelector` to choose the appropriate tracing configuration based on request context:
 
 ```ts title="src/mastra/index.ts" showLineNumbers copy
 export const mastra = new Mastra({
-  observability: {
+  observability: new Observability({
     default: { enabled: true }, // Provides 'default' instance
     configs: {
       langfuse: {
@@ -212,24 +218,24 @@ export const mastra = new Mastra({
     },
     configSelector: (context, availableTracers) => {
       // Use debug config for support requests
-      if (context.runtimeContext?.get("supportMode")) {
+      if (context.requestContext?.get("supportMode")) {
         return "debug";
       }
 
       // Route specific customers to different providers
-      const customerId = context.runtimeContext?.get("customerId");
+      const customerId = context.requestContext?.get("customerId");
       if (customerId && premiumCustomers.includes(customerId)) {
         return "braintrust";
       }
 
       // Route specific requests to langfuse
-      if (context.runtimeContext?.get("useExternalTracing")) {
+      if (context.requestContext?.get("useExternalTracing")) {
         return "langfuse";
       }
 
       return "default";
     },
-  },
+  }),
 });
 ```
 
@@ -239,7 +245,7 @@ A common pattern is to select configurations based on deployment environment:
 
 ```ts title="src/mastra/index.ts" showLineNumbers copy
 export const mastra = new Mastra({
-  observability: {
+  observability: new Observability({
     configs: {
       development: {
         serviceName: "my-service-dev",
@@ -261,19 +267,19 @@ export const mastra = new Mastra({
       const env = process.env.NODE_ENV || "development";
       return env;
     },
-  },
+  }),
 });
 ```
 
 ### Common Configuration Patterns & Troubleshooting
 
-#### Default Config Takes Priority
+#### Default & Custom Configs
 
-When you have both the default config enabled and custom configs defined, **the default config will always be used** unless you explicitly select a different config:
+Having both the default config enabled and adding custom configs is an invalid configuration of Observability. Use either the default or custom config, but not both.
 
 ```ts title="src/mastra/index.ts" showLineNumbers copy
 export const mastra = new Mastra({
-  observability: {
+  observability: new Observability({
     default: { enabled: true }, // This will always be used!
     configs: {
       langfuse: {
@@ -281,51 +287,20 @@ export const mastra = new Mastra({
         exporters: [langfuseExporter], // This won't be reached
       },
     },
-  },
+  }),
 });
 ```
 
-**Solutions:**
-
-1. **Disable the default** and use only custom configs:
-
-```ts
-observability: {
-  // comment out or remove this line to disable the default config
-  // default: { enabled: true },
-  configs: {
-    langfuse: {
-      /* ... */
-    }
-  }
-}
-```
-
-2. **Use a configSelector** to choose between configs:
-
-```ts
-observability: {
-  default: { enabled: true },
-  configs: {
-    langfuse: { /* ... */ }
-  },
-  configSelector: (context, availableConfigs) => {
-    // Logic to choose between 'default' and 'langfuse'
-    return useExternalTracing ? 'langfuse' : 'default';
-  }
-}
-```
-
 #### Maintaining Studio and Cloud Access
 
 When creating a custom config with external exporters, you might lose access to Studio and Cloud. To maintain access while adding external exporters, include the default exporters in your custom config:
 
 ```ts title="src/mastra/index.ts" showLineNumbers copy
-import { DefaultExporter, CloudExporter } from "@mastra/core/ai-tracing";
+import { DefaultExporter, CloudExporter } from "@mastra/observability";
 import { ArizeExporter } from "@mastra/arize";
 
 export const mastra = new Mastra({
-  observability: {
+  observability: new Observability({
     default: { enabled: false }, // Disable default to use custom
     configs: {
       production: {
@@ -341,7 +316,7 @@ export const mastra = new Mastra({
         ],
       },
     },
-  },
+  }),
 });
 ```
 
@@ -385,58 +360,58 @@ execute: async ({ inputData, tracingContext }) => {
 
 Metadata set here will be shown in all configured exporters.
 
-### Automatic Metadata from RuntimeContext
+### Automatic Metadata from RequestContext
 
-Instead of manually adding metadata to each span, you can configure Mastra to automatically extract values from RuntimeContext and attach them as metadata to all spans in a trace. This is useful for consistently tracking user identifiers, environment information, feature flags, or any request-scoped data across your entire trace.
+Instead of manually adding metadata to each span, you can configure Mastra to automatically extract values from RequestContext and attach them as metadata to all spans in a trace. This is useful for consistently tracking user identifiers, environment information, feature flags, or any request-scoped data across your entire trace.
 
 #### Configuration-Level Extraction
 
-Define which RuntimeContext keys to extract in your tracing configuration. These keys will be automatically included as metadata for all spans created with this configuration:
+Define which RequestContext keys to extract in your tracing configuration. These keys will be automatically included as metadata for all spans created with this configuration:
 
 ```ts title="src/mastra/index.ts" showLineNumbers copy
 export const mastra = new Mastra({
-  observability: {
+  observability: new Observability({
     configs: {
       default: {
         serviceName: "my-service",
-        runtimeContextKeys: ["userId", "environment", "tenantId"],
+        requestContextKeys: ["userId", "environment", "tenantId"],
         exporters: [new DefaultExporter()],
       },
     },
-  },
+  }),
 });
 ```
 
-Now when you execute agents or workflows with a RuntimeContext, these values are automatically extracted:
+Now when you execute agents or workflows with a RequestContext, these values are automatically extracted:
 
 ```ts showLineNumbers copy
-const runtimeContext = new RuntimeContext();
-runtimeContext.set("userId", "user-123");
-runtimeContext.set("environment", "production");
-runtimeContext.set("tenantId", "tenant-456");
+const requestContext = new RequestContext();
+requestContext.set("userId", "user-123");
+requestContext.set("environment", "production");
+requestContext.set("tenantId", "tenant-456");
 
 // All spans in this trace automatically get userId, environment, and tenantId metadata
 const result = await agent.generate({
   messages: [{ role: "user", content: "Hello" }],
-  runtimeContext,
+  requestContext,
 });
 ```
 
 #### Per-Request Additions
 
-You can add trace-specific keys using `tracingOptions.runtimeContextKeys`. These are merged with the configuration-level keys:
+You can add trace-specific keys using `tracingOptions.requestContextKeys`. These are merged with the configuration-level keys:
 
 ```ts showLineNumbers copy
-const runtimeContext = new RuntimeContext();
-runtimeContext.set("userId", "user-123");
-runtimeContext.set("environment", "production");
-runtimeContext.set("experimentId", "exp-789");
+const requestContext = new RequestContext();
+requestContext.set("userId", "user-123");
+requestContext.set("environment", "production");
+requestContext.set("experimentId", "exp-789");
 
 const result = await agent.generate({
   messages: [{ role: "user", content: "Hello" }],
-  runtimeContext,
+  requestContext,
   tracingOptions: {
-    runtimeContextKeys: ["experimentId"], // Adds to configured keys
+    requestContextKeys: ["experimentId"], // Adds to configured keys
   },
 });
 
@@ -445,23 +420,23 @@ const result = await agent.generate({
 
 #### Nested Value Extraction
 
-Use dot notation to extract nested values from RuntimeContext:
+Use dot notation to extract nested values from RequestContext:
 
 ```ts showLineNumbers copy
 export const mastra = new Mastra({
-  observability: {
+  observability: new Observability({
     configs: {
       default: {
-        runtimeContextKeys: ["user.id", "session.data.experimentId"],
+        requestContextKeys: ["user.id", "session.data.experimentId"],
         exporters: [new DefaultExporter()],
       },
     },
-  },
+  }),
 });
 
-const runtimeContext = new RuntimeContext();
-runtimeContext.set("user", { id: "user-456", name: "John Doe" });
-runtimeContext.set("session", { data: { experimentId: "exp-999" } });
+const requestContext = new RequestContext();
+requestContext.set("user", { id: "user-456", name: "John Doe" });
+requestContext.set("session", { data: { experimentId: "exp-999" } });
 
 // Metadata will include: { user: { id: 'user-456' }, session: { data: { experimentId: 'exp-999' } } }
 ```
@@ -469,38 +444,38 @@ runtimeContext.set("session", { data: { experimentId: "exp-999" } });
 #### How It Works
 
 1. **TraceState Computation**: At the start of a trace (root span creation), Mastra computes which keys to extract by merging configuration-level and per-request keys
-2. **Automatic Extraction**: Root spans (agent runs, workflow executions) automatically extract metadata from RuntimeContext
-3. **Child Span Extraction**: Child spans can also extract metadata if you pass `runtimeContext` when creating them
+2. **Automatic Extraction**: Root spans (agent runs, workflow executions) automatically extract metadata from RequestContext
+3. **Child Span Extraction**: Child spans can also extract metadata if you pass `requestContext` when creating them
 4. **Metadata Precedence**: Explicit metadata passed to span options always takes precedence over extracted metadata
 
 #### Child Spans and Metadata Extraction
 
-When creating child spans within tools or workflow steps, you can pass the `runtimeContext` parameter to enable metadata extraction:
+When creating child spans within tools or workflow steps, you can pass the `requestContext` parameter to enable metadata extraction:
 
 ```ts showLineNumbers copy
-execute: async ({ tracingContext, runtimeContext }) => {
-  // Create child span WITH runtimeContext - gets metadata extraction
+execute: async ({ tracingContext, requestContext }) => {
+  // Create child span WITH requestContext - gets metadata extraction
   const dbSpan = tracingContext.currentSpan?.createChildSpan({
     type: "generic",
     name: "database-query",
-    runtimeContext, // Pass to enable metadata extraction
+    requestContext, // Pass to enable metadata extraction
   });
 
   const results = await db.query("SELECT * FROM users");
   dbSpan?.end({ output: results });
 
-  // Or create child span WITHOUT runtimeContext - no metadata extraction
+  // Or create child span WITHOUT requestContext - no metadata extraction
   const cacheSpan = tracingContext.currentSpan?.createChildSpan({
     type: "generic",
     name: "cache-check",
-    // No runtimeContext - won't extract metadata
+    // No requestContext - won't extract metadata
   });
 
   return results;
 };
 ```
 
-This gives you fine-grained control over which child spans include RuntimeContext metadata. Root spans (agent/workflow executions) always extract metadata automatically, while child spans only extract when you explicitly pass `runtimeContext`.
+This gives you fine-grained control over which child spans include RequestContext metadata. Root spans (agent/workflow executions) always extract metadata automatically, while child spans only extract when you explicitly pass `requestContext`.
 
 ## Creating Child Spans
 
@@ -509,17 +484,17 @@ Child spans allow you to track fine-grained operations within your workflow step
 Create child spans inside a tool call or workflow step to track specific operations:
 
 ```ts showLineNumbers copy
-execute: async ({ input, tracingContext }) => {
+execute: async ({ inputData, tracingContext }) => {
   // Create another child span for the main database operation
   const querySpan = tracingContext.currentSpan?.createChildSpan({
     type: "generic",
     name: "database-query",
-    input: { query: input.query },
+    input: { query: inputData.query },
     metadata: { database: "production" },
   });
 
   try {
-    const results = await db.query(input.query);
+    const results = await db.query(inputData.query);
     querySpan?.end({
       output: results.data,
       metadata: {
@@ -547,19 +522,19 @@ Span processors allow you to transform, filter, or enrich trace data before it's
 
 ### Built-in Processors
 
-- [Sensitive Data Filter](/docs/observability/ai-tracing/processors/sensitive-data-filter) redacts sensitive information. It is enabled in the default observability config.
+- [Sensitive Data Filter]/docs/v1/observability/tracing/processors/sensitive-data-filter) redacts sensitive information. It is enabled in the default observability config.
 
 ### Creating Custom Processors
 
-You can create custom span processors by implementing the `AISpanProcessor` interface. Here's a simple example that converts all input text in spans to lowercase:
+You can create custom span processors by implementing the `SpanOutputProcessor` interface. Here's a simple example that converts all input text in spans to lowercase:
 
 ```ts title="src/processors/lowercase-input-processor.ts" showLineNumbers copy
-import type { AISpanProcessor, AnyAISpan } from "@mastra/core/ai-tracing";
+import type { SpanOutputProcessor, AnySpan } from "@mastra/observability";
 
-export class LowercaseInputProcessor implements AISpanProcessor {
+export class LowercaseInputProcessor implements SpanOutputProcessor {
   name = "lowercase-processor";
 
-  process(span: AnyAISpan): AnyAISpan {
+  process(span: AnySpan): AnySpan {
     span.input = `${span.input}`.toLowerCase();
     return span;
   }
@@ -571,14 +546,14 @@ export class LowercaseInputProcessor implements AISpanProcessor {
 
 // Use the custom processor
 export const mastra = new Mastra({
-  observability: {
+  observability: new Observability({
     configs: {
       development: {
-        processors: [new LowercaseInputProcessor(), new SensitiveDataFilter()],
+        spanOutputProcessors: [new LowercaseInputProcessor(), new SensitiveDataFilter()],
         exporters: [new DefaultExporter()],
       },
     },
-  },
+  }),
 });
 ```
 
@@ -620,7 +595,7 @@ Workflow executions also return trace IDs:
 
 ```ts showLineNumbers copy
 // Create a workflow run
-const run = await mastra.getWorkflow("myWorkflow").createRunAsync();
+const run = await mastra.getWorkflow("myWorkflow").createRun();
 
 // Start the workflow
 const result = await run.start({
@@ -701,7 +676,7 @@ Workflows support the same pattern for trace propagation:
 
 ```ts showLineNumbers copy
 const workflow = mastra.getWorkflow("data-pipeline");
-const run = await workflow.createRunAsync();
+const run = await workflow.createRun();
 
 const result = await run.start({
   inputData: { data: "..." },
@@ -774,39 +749,29 @@ Mastra automatically creates spans for:
 - **Control flow** - Conditionals, loops, parallel execution
 - **Wait operations** - Delays and event waiting
 
-## Viewing Traces
-
-Traces are available in multiple locations:
-
-- **Studio** - Local development environment
-- **Mastra Cloud** - Production monitoring dashboard
-- **Arize Phoenix / Arize AX** - When using Arize exporter
-- **Braintrust Console** - When using Braintrust exporter
-- **Langfuse Dashboard** - When using Langfuse exporter
-
 ## See Also
 
 ### Examples
 
-- [Basic AI Tracing Example](/examples/observability/basic-ai-tracing) - Working implementation
+- [Basic Tracing Example]/examples/v1/observability/basic-tracing) - Working implementation
 
 ### Reference Documentation
 
-- [Configuration API](/reference/observability/ai-tracing/configuration) - ObservabilityConfig details
-- [AITracing Classes](/reference/observability/ai-tracing/) - Core classes and methods
-- [Span Interfaces](/reference/observability/ai-tracing/span) - Span types and lifecycle
-- [Type Definitions](/reference/observability/ai-tracing/interfaces) - Complete interface reference
+- [Configuration API]/reference/v1/observability/tracing/configuration) - ObservabilityConfig details
+- [Tracing Classes]/reference/v1/observability/tracing/instances) - Core classes and methods
+- [Span Interfaces]/reference/v1/observability/tracing/spans) - Span types and lifecycle
+- [Type Definitions]/reference/v1/observability/tracing/interfaces) - Complete interface reference
 
 ### Exporters
 
-- [DefaultExporter](/reference/observability/ai-tracing/exporters/default-exporter) - Storage persistence
-- [CloudExporter](/reference/observability/ai-tracing/exporters/cloud-exporter) - Mastra Cloud integration
-- [ConsoleExporter](/reference/observability/ai-tracing/exporters/console-exporter) - Debug output
-- [Arize](/reference/observability/ai-tracing/exporters/arize) - Arize Phoenix and Arize AX integration
-- [Braintrust](/reference/observability/ai-tracing/exporters/braintrust) - Braintrust integration
-- [Langfuse](/reference/observability/ai-tracing/exporters/langfuse) - Langfuse integration
-- [OpenTelemetry](/reference/observability/ai-tracing/exporters/otel) - OTEL-compatible platforms
+- [DefaultExporter]/reference/v1/observability/tracing/exporters/default-exporter) - Storage persistence
+- [CloudExporter]/reference/v1/observability/tracing/exporters/cloud-exporter) - Mastra Cloud integration
+- [ConsoleExporter]/reference/v1/observability/tracing/exporters/console-exporter) - Debug output
+- [Arize]/reference/v1/observability/tracing/exporters/arize) - Arize Phoenix and Arize AX integration
+- [Braintrust]/reference/v1/observability/tracing/exporters/braintrust) - Braintrust integration
+- [Langfuse]/reference/v1/observability/tracing/exporters/langfuse) - Langfuse integration
+- [OpenTelemetry]/reference/v1/observability/tracing/exporters/otel) - OTEL-compatible platforms
 
 ### Processors
 
-- [Sensitive Data Filter](/docs/observability/ai-tracing/processors/sensitive-data-filter) - Data redaction
+- [Sensitive Data Filter]/docs/v1/observability/tracing/processors/sensitive-data-filter) - Data redaction

package/.docs/raw/observability/{ai-tracing → tracing}/processors/sensitive-data-filter.mdx

@@ -1,11 +1,11 @@
 ---
 title: "Sensitive Data Filter | Processors | Observability | Mastra Docs"
-description: "Protect sensitive information in your AI traces with automatic data redaction"
+description: "Protect sensitive information in your traces with automatic data redaction"
 ---
 
 # Sensitive Data Filter
 
-The Sensitive Data Filter is a span processor that automatically redacts sensitive information from your AI traces before they're exported. This ensures that passwords, API keys, tokens, and other confidential data never leave your application or get stored in observability platforms.
+The Sensitive Data Filter is a span processor that automatically redacts sensitive information from your traces before they're exported. This ensures that passwords, API keys, tokens, and other confidential data never leave your application or get stored in observability platforms.
 
 ## Default Configuration
 
@@ -13,10 +13,11 @@ By default, the Sensitive Data Filter is automatically enabled when you use the
 
 ```ts title="src/mastra/index.ts" showLineNumbers copy
 export const mastra = new Mastra({
-  observability: {
+  observability: new Observability({
     default: { enabled: true }, // Automatically includes SensitiveDataFilter
-  },
+  }),
   storage: new LibSQLStore({
+    id: 'mastra-storage',
     url: "file:./mastra.db",
   }),
 });
@@ -63,15 +64,15 @@ When a sensitive field is detected, its value is replaced with `[REDACTED]` by d
 You can customize which fields are redacted and how redaction appears:
 
 ```ts title="src/mastra/index.ts" showLineNumbers copy
-import { SensitiveDataFilter, DefaultExporter } from "@mastra/core/ai-tracing";
+import { SensitiveDataFilter, DefaultExporter, Observability } from "@mastra/observability";
 
 export const mastra = new Mastra({
-  observability: {
+  observability: new Observability({
     configs: {
       production: {
         serviceName: "my-service",
         exporters: [new DefaultExporter()],
-        processors: [
+        spanOutputProcessors: [
           new SensitiveDataFilter({
             // Add custom sensitive fields
             sensitiveFields: [
@@ -97,7 +98,7 @@ export const mastra = new Mastra({
         ],
       },
     },
-  },
+  }),
 });
 ```
 
@@ -211,15 +212,15 @@ If you need to disable sensitive data filtering (not recommended for production)
 
 ```ts title="src/mastra/index.ts" showLineNumbers copy
 export const mastra = new Mastra({
-  observability: {
+  observability: new Observability({
     configs: {
       debug: {
         serviceName: "debug-service",
-        processors: [], // No processors, including no SensitiveDataFilter
+        spanOutputProcessors: [], // No processors, including no SensitiveDataFilter
         exporters: [new DefaultExporter()],
       },
     },
-  },
+  }),
 });
 ```
 
@@ -291,5 +292,5 @@ This ensures that processing errors don't prevent traces from being exported or
 
 ## Related
 
-- [SensitiveDataFilter API](/reference/observability/ai-tracing/processors/sensitive-data-filter)
-- [Basic AI Tracing Example](/examples/observability/basic-ai-tracing)
+- [SensitiveDataFilter API]/reference/v1/observability/tracing/processors/sensitive-data-filter)
+- [Basic Tracing Example]/examples/v1/observability/basic-tracing)