# DefaultExporter
[EN] Source: https://mastra.ai/reference/observability/ai-tracing/exporters/default-exporter

Persists traces to Mastra's configured storage with automatic batching and retry logic.

## Constructor

```typescript
new DefaultExporter(config?: BatchingConfig, logger?: IMastraLogger)
```

<PropertiesTable
  props={[
    {
      name: "config",
      type: "BatchingConfig",
      description: "Batching configuration options",
      required: false,
    },
    {
      name: "logger",
      type: "IMastraLogger",
      description:
        "Logger instance. Falls back to ConsoleLogger with INFO level if not provided",
      required: false,
    },
  ]}
/>

## BatchingConfig

```typescript
interface BatchingConfig {
  /** Maximum number of spans per batch. Default: 1000 */
  maxBatchSize?: number;

  /** Maximum total buffer size before emergency flush. Default: 10000 */
  maxBufferSize?: number;

  /** Maximum time to wait before flushing batch in milliseconds. Default: 5000 */
  maxBatchWaitMs?: number;

  /** Maximum number of retry attempts. Default: 4 */
  maxRetries?: number;

  /** Base retry delay in milliseconds (uses exponential backoff). Default: 500 */
  retryDelayMs?: number;

  /** Tracing strategy or 'auto' for automatic selection. Default: 'auto' */
  strategy?: TracingStrategy | "auto";
}
```

## TracingStrategy

```typescript
type TracingStrategy = "realtime" | "batch-with-updates" | "insert-only";
```

### Strategy Behaviors

- **realtime**: Immediately persists each event to storage
- **batch-with-updates**: Batches creates and updates separately, applies in order
- **insert-only**: Only processes SPAN_ENDED events, ignores updates

## Properties

```typescript
readonly name = 'tracing-default-exporter';
```

## Methods

### \_\_registerMastra

```typescript
__registerMastra(mastra: Mastra): void
```

Registers the Mastra instance. Called automatically after Mastra construction.

### init

```typescript
init(): void
```

Initializes the exporter after dependencies are ready. Resolves tracing strategy based on storage capabilities.

### exportEvent

```typescript
async exportEvent(event: AITracingEvent): Promise<void>
```

Processes a tracing event according to the resolved strategy.

<PropertiesTable
  props={[
    {
      name: "event",
      type: "AITracingEvent",
      description: "The tracing event to export",
      required: true,
    },
  ]}
/>

### shutdown

```typescript
async shutdown(): Promise<void>
```

Flushes remaining buffered events and performs cleanup.

## Automatic Strategy Selection

When `strategy: 'auto'` (default), the exporter queries the storage adapter for its capabilities:

```typescript
interface AITracingStrategy {
  /** Strategies supported by this adapter */
  supported: TracingStrategy[];

  /** Preferred strategy for optimal performance */
  preferred: TracingStrategy;
}
```

The exporter will:

1. Use the storage adapter's preferred strategy if available
2. Fall back to the first supported strategy if preferred isn't available
3. Log a warning if a user-specified strategy isn't supported

## Batching Behavior

### Flush Triggers

The buffer flushes when any of these conditions are met:

- Buffer size reaches `maxBatchSize`
- Time since first buffered event exceeds `maxBatchWaitMs`
- Buffer size reaches `maxBufferSize` (emergency flush)
- `shutdown()` is called

### Retry Logic

Failed flushes are retried with exponential backoff:

- Retry delay: `retryDelayMs * 2^attempt`
- Maximum attempts: `maxRetries`
- Batch is dropped after all retries fail

### Out-of-Order Handling

For `batch-with-updates` strategy:

- Tracks which spans have been created
- Rejects updates/ends for spans not yet created
- Logs warnings for out-of-order events
- Maintains sequence numbers for ordered updates

## Usage

```typescript
import { DefaultExporter } from "@mastra/core/ai-tracing";

// Default configuration
const exporter = new DefaultExporter();

// Custom batching configuration
const customExporter = new DefaultExporter({
  maxBatchSize: 500,
  maxBatchWaitMs: 2000,
  strategy: "batch-with-updates",
});
```

## See Also

### Documentation

- [AI Tracing Overview](/docs/observability/ai-tracing/overview) - Complete guide
- [Exporters](/docs/observability/ai-tracing/overview#exporters) - Exporter concepts

### Other Exporters

- [CloudExporter](/reference/observability/ai-tracing/exporters/cloud-exporter) - Mastra Cloud
- [ConsoleExporter](/reference/observability/ai-tracing/exporters/console-exporter) - Debug output
- [Langfuse](/reference/observability/ai-tracing/exporters/langfuse) - Langfuse integration
- [Braintrust](/reference/observability/ai-tracing/exporters/braintrust) - Braintrust integration

### Reference

- [Configuration](/reference/observability/ai-tracing/configuration) - Configuration options
- [Interfaces](/reference/observability/ai-tracing/interfaces) - Type definitions


---
title: "Reference: LangfuseExporter | Observability"
description: Langfuse exporter for AI tracing
---

import PropertiesTable from "@site/src/components/PropertiesTable";