@uploadista/observability 0.0.18-beta.9 → 0.0.18

package/dist/index.d.cts

@@ -1,9 +1,15 @@
-import { Context, Effect, Layer, Metric, Option } from "effect";
+import { Context, Effect, Layer, Logger, Metric, Option, Tracer } from "effect";
 import * as effect_MetricKeyType7 from "effect/MetricKeyType";
 import * as effect_MetricState7 from "effect/MetricState";
-import * as effect_Tracer0 from "effect/Tracer";
-import * as _effect_opentelemetry_Resource0 from "@effect/opentelemetry/Resource";
-import * as effect_Metric24 from "effect/Metric";
+import { OTLPLogExporter, OTLPLogExporter as OTLPLogExporter$1 } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter, OTLPMetricExporter as OTLPMetricExporter$1 } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { BatchLogRecordProcessor, LoggerProvider, LoggerProvider as LoggerProvider$1 } from "@opentelemetry/sdk-logs";
+import { MeterProvider, MeterProvider as MeterProvider$1, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import * as _effect_opentelemetry_Resource7 from "@effect/opentelemetry/Resource";
+import { Meter } from "@opentelemetry/api";
+import { Logger as Logger$1, SeverityNumber, SeverityNumber as SeverityNumber$1 } from "@opentelemetry/api-logs";
+import * as effect_Metric49 from "effect/Metric";
 
 //#region src/core/metrics.d.ts
 declare const createUploadMetrics: (storageType: string) => {
@@ -49,6 +55,953 @@ declare const createStorageErrorClassifier: (storageType: string, customErrorMap
 declare const trackStorageError: (storageType: string, metrics: StorageMetrics, operation: string, error: unknown, context?: Record<string, unknown>, errorClassifier?: (error: unknown) => StorageErrorCategory) => Effect.Effect<void, never, never>;
 declare const createStorageErrorTracker: (storageType: string, metrics: StorageMetrics, customErrorClassifier?: (error: unknown) => StorageErrorCategory | null) => (operation: string, error: unknown, context?: Record<string, unknown>) => Effect.Effect<void, never, never>;
 //#endregion
+//#region src/core/exporters.d.ts
+/**
+ * Configuration options for OTLP exporters.
+ */
+interface OtlpExporterConfig {
+  /** Base endpoint URL. Defaults to OTEL_EXPORTER_OTLP_ENDPOINT or http://localhost:4318 */
+  endpoint?: string;
+  /** Headers to include in requests (for authentication). Defaults to OTEL_EXPORTER_OTLP_HEADERS */
+  headers?: Record<string, string>;
+  /** Request timeout in milliseconds. Defaults to 5000 */
+  timeoutMillis?: number;
+}
+/**
+ * Parses the OTEL_EXPORTER_OTLP_HEADERS environment variable.
+ *
+ * Format: key=value,key2=value2
+ * Example: Authorization=Basic abc123,X-Custom-Header=value
+ *
+ * @returns Parsed headers as a Record, or undefined if not set
+ */
+declare function parseOtlpHeaders(): Record<string, string> | undefined;
+/**
+ * Gets the OTLP endpoint from environment variables with fallback.
+ *
+ * Checks in order:
+ * 1. Provided endpoint parameter
+ * 2. Signal-specific endpoint (OTEL_EXPORTER_OTLP_TRACES_ENDPOINT, OTEL_EXPORTER_OTLP_METRICS_ENDPOINT, or OTEL_EXPORTER_OTLP_LOGS_ENDPOINT)
+ * 3. Base endpoint (OTEL_EXPORTER_OTLP_ENDPOINT)
+ * 4. Default: http://localhost:4318
+ *
+ * @param signal - The signal type ('traces', 'metrics', or 'logs')
+ * @param configEndpoint - Optional endpoint from config
+ * @returns The resolved endpoint URL
+ */
+declare function getOtlpEndpoint(signal: "traces" | "metrics" | "logs", configEndpoint?: string): string;
+/**
+ * Creates an OTLP trace exporter configured from environment variables.
+ *
+ * The exporter sends traces to an OTLP-compatible endpoint using HTTP/protobuf.
+ *
+ * @param config - Optional configuration overrides
+ * @returns Configured OTLPTraceExporter instance
+ *
+ * @example
+ * ```typescript
+ * // Use environment variables
+ * const exporter = createOtlpTraceExporter();
+ *
+ * // Override endpoint
+ * const exporter = createOtlpTraceExporter({
+ *   endpoint: 'https://otlp.grafana.net'
+ * });
+ * ```
+ */
+declare function createOtlpTraceExporter(config?: OtlpExporterConfig): OTLPTraceExporter;
+/**
+ * Creates an OTLP metric exporter configured from environment variables.
+ *
+ * The exporter sends metrics to an OTLP-compatible endpoint using HTTP/protobuf.
+ *
+ * @param config - Optional configuration overrides
+ * @returns Configured OTLPMetricExporter instance
+ *
+ * @example
+ * ```typescript
+ * // Use environment variables
+ * const exporter = createOtlpMetricExporter();
+ *
+ * // Override endpoint
+ * const exporter = createOtlpMetricExporter({
+ *   endpoint: 'https://otlp.grafana.net'
+ * });
+ * ```
+ */
+declare function createOtlpMetricExporter(config?: OtlpExporterConfig): OTLPMetricExporter$1;
+/**
+ * Checks if observability is enabled via environment variable.
+ *
+ * Reads UPLOADISTA_OBSERVABILITY_ENABLED environment variable.
+ * Defaults to true if not set.
+ *
+ * @returns true if observability should be enabled
+ */
+declare function isOtlpExportEnabled(): boolean;
+/**
+ * Gets the service name from environment variables.
+ *
+ * Reads OTEL_SERVICE_NAME environment variable.
+ * Defaults to "uploadista" if not set.
+ *
+ * @param defaultName - Default service name if not configured
+ * @returns The service name to use
+ */
+declare function getServiceName(defaultName?: string): string;
+/**
+ * Parses resource attributes from OTEL_RESOURCE_ATTRIBUTES environment variable.
+ *
+ * Format: key=value,key2=value2
+ * Example: tenant.id=abc123,deployment.environment=production
+ *
+ * @returns Parsed attributes as a Record, or empty object if not set
+ */
+declare function parseResourceAttributes(): Record<string, string>;
+/**
+ * Creates an OTLP log exporter configured from environment variables.
+ *
+ * The exporter sends logs to an OTLP-compatible endpoint using HTTP/protobuf.
+ *
+ * @param config - Optional configuration overrides
+ * @returns Configured OTLPLogExporter instance
+ *
+ * @example
+ * ```typescript
+ * // Use environment variables
+ * const exporter = createOtlpLogExporter();
+ *
+ * // Override endpoint
+ * const exporter = createOtlpLogExporter({
+ *   endpoint: 'https://otlp.grafana.net'
+ * });
+ * ```
+ */
+declare function createOtlpLogExporter(config?: OtlpExporterConfig): OTLPLogExporter$1;
+/**
+ * Configuration for metrics export.
+ */
+interface MetricsSdkConfig extends OtlpExporterConfig {
+  /** Service name for metrics. Defaults to OTEL_SERVICE_NAME or "uploadista" */
+  serviceName?: string;
+  /** Export interval in milliseconds. Defaults to OTEL_METRICS_EXPORT_INTERVAL or 60000 */
+  exportIntervalMillis?: number;
+  /** Export timeout in milliseconds. Defaults to 30000 */
+  exportTimeoutMillis?: number;
+}
+/**
+ * Gets the metrics export interval from environment or config.
+ *
+ * @param configInterval - Optional interval from config
+ * @returns Export interval in milliseconds
+ */
+declare function getMetricsExportInterval(configInterval?: number): number;
+/**
+ * Creates an OTLP MeterProvider with PeriodicExportingMetricReader.
+ *
+ * The MeterProvider is pre-configured with:
+ * - OTLP HTTP exporter for metrics
+ * - Periodic export based on OTEL_METRICS_EXPORT_INTERVAL (default: 60s)
+ * - Graceful error handling (failures logged, not thrown)
+ *
+ * @param config - Optional configuration
+ * @returns Configured MeterProvider instance
+ *
+ * @example
+ * ```typescript
+ * const meterProvider = createOtlpMeterProvider();
+ * const meter = meterProvider.getMeter("uploadista");
+ * const counter = meter.createCounter("uploads_total");
+ * counter.add(1, { storage: "s3" });
+ * ```
+ */
+declare function createOtlpMeterProvider(config?: MetricsSdkConfig): MeterProvider$1;
+/**
+ * Configuration for logs export.
+ */
+interface LogsSdkConfig extends OtlpExporterConfig {
+  /** Service name for logs. Defaults to OTEL_SERVICE_NAME or "uploadista" */
+  serviceName?: string;
+  /** Maximum queue size for batch processor. Defaults to 512 */
+  maxQueueSize?: number;
+  /** Maximum export batch size. Defaults to 512 */
+  maxExportBatchSize?: number;
+  /** Schedule delay in milliseconds. Defaults to OTEL_LOGS_EXPORT_INTERVAL or 5000 */
+  scheduledDelayMillis?: number;
+  /** Export timeout in milliseconds. Defaults to 30000 */
+  exportTimeoutMillis?: number;
+}
+/**
+ * Gets the logs export interval from environment or config.
+ *
+ * @param configInterval - Optional interval from config
+ * @returns Export interval in milliseconds
+ */
+declare function getLogsExportInterval(configInterval?: number): number;
+/**
+ * Creates an OTLP LoggerProvider with BatchLogRecordProcessor.
+ *
+ * The LoggerProvider is pre-configured with:
+ * - OTLP HTTP exporter for logs
+ * - Batch processing with configurable queue and batch sizes
+ * - Graceful error handling (failures logged, not thrown)
+ *
+ * @param config - Optional configuration
+ * @returns Configured LoggerProvider instance
+ *
+ * @example
+ * ```typescript
+ * const loggerProvider = createOtlpLoggerProvider();
+ * const logger = loggerProvider.getLogger("uploadista");
+ * logger.emit({
+ *   severityNumber: SeverityNumber.INFO,
+ *   body: "Upload completed",
+ *   attributes: { uploadId: "123" },
+ * });
+ * ```
+ */
+declare function createOtlpLoggerProvider(config?: LogsSdkConfig): LoggerProvider$1;
+//#endregion
+//#region src/core/metrics-sdk.d.ts
+/**
+ * OpenTelemetry Meter service for recording metrics.
+ */
+interface OtelMeterService {
+  /** The OpenTelemetry Meter instance */
+  readonly meter: Meter;
+  /** The MeterProvider for shutdown handling */
+  readonly provider: MeterProvider$1;
+}
+declare const OtelMeter_base: Context.TagClass<OtelMeter, "OtelMeter", OtelMeterService>;
+/**
+ * Effect Context tag for the OTEL Meter service.
+ */
+declare class OtelMeter extends OtelMeter_base {}
+/**
+ * Node.js OTLP Metrics SDK Layer for production use.
+ *
+ * Exports metrics to an OTLP-compatible endpoint configured via environment variables.
+ *
+ * @example
+ * ```typescript
+ * import { OtlpMetricsNodeSdkLive, OtelMeter } from "@uploadista/observability";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const { meter } = yield* OtelMeter;
+ *   const counter = meter.createCounter("uploads_total");
+ *   counter.add(1, { storage: "s3" });
+ * }).pipe(Effect.provide(OtlpMetricsNodeSdkLive));
+ * ```
+ */
+declare const OtlpMetricsNodeSdkLive: Layer.Layer<OtelMeter, never, never>;
+/**
+ * Creates a customized OTLP Metrics Node.js SDK Layer.
+ *
+ * @param config - Custom configuration options
+ * @returns Configured Effect Layer
+ *
+ * @example
+ * ```typescript
+ * const customMetrics = createOtlpMetricsNodeSdkLayer({
+ *   serviceName: "my-upload-service",
+ *   exportIntervalMillis: 30000, // Export every 30 seconds
+ * });
+ * ```
+ */
+declare function createOtlpMetricsNodeSdkLayer(config?: MetricsSdkConfig): Layer.Layer<OtelMeter, never, never>;
+/**
+ * Browser OTLP Metrics SDK Layer for production use.
+ *
+ * Uses the same OTLP HTTP exporter, suitable for browser environments.
+ * Note: Browser environments may have CORS restrictions.
+ *
+ * @example
+ * ```typescript
+ * import { OtlpMetricsWebSdkLive } from "@uploadista/observability";
+ *
+ * const program = myEffect.pipe(Effect.provide(OtlpMetricsWebSdkLive));
+ * ```
+ */
+declare const OtlpMetricsWebSdkLive: Layer.Layer<OtelMeter, never, never>;
+/**
+ * Creates a customized OTLP Metrics Web SDK Layer.
+ *
+ * @param config - Custom configuration options
+ * @returns Configured Effect Layer for browser environments
+ */
+declare function createOtlpMetricsWebSdkLayer(config?: MetricsSdkConfig): Layer.Layer<OtelMeter, never, never>;
+/**
+ * Cloudflare Workers OTLP Metrics SDK Layer for production use.
+ *
+ * Pre-configured with Workers-appropriate defaults.
+ *
+ * @example
+ * ```typescript
+ * import { OtlpMetricsWorkersSdkLive } from "@uploadista/observability";
+ *
+ * export default {
+ *   async fetch(request, env) {
+ *     const program = handleRequest(request).pipe(
+ *       Effect.provide(OtlpMetricsWorkersSdkLive)
+ *     );
+ *     return Effect.runPromise(program);
+ *   }
+ * };
+ * ```
+ */
+declare const OtlpMetricsWorkersSdkLive: Layer.Layer<OtelMeter, never, never>;
+/**
+ * Creates a customized OTLP Metrics Workers SDK Layer.
+ *
+ * @param config - Custom configuration options
+ * @returns Configured Effect Layer for Cloudflare Workers
+ */
+declare function createOtlpMetricsWorkersSdkLayer(config?: MetricsSdkConfig): Layer.Layer<OtelMeter, never, never>;
+/**
+ * Records a counter metric using the OTEL Meter from context.
+ *
+ * @param name - Counter name
+ * @param value - Value to add (default: 1)
+ * @param attributes - Optional metric attributes
+ * @returns Effect that records the counter
+ *
+ * @example
+ * ```typescript
+ * yield* recordCounter("uploads_total", 1, { storage: "s3" });
+ * ```
+ */
+declare const recordCounter: (name: string, value?: number, attributes?: Record<string, string | number | boolean>) => Effect.Effect<void, never, OtelMeter>;
+/**
+ * Records a histogram metric using the OTEL Meter from context.
+ *
+ * @param name - Histogram name
+ * @param value - Value to record
+ * @param attributes - Optional metric attributes
+ * @returns Effect that records the histogram
+ *
+ * @example
+ * ```typescript
+ * yield* recordHistogram("upload_duration_seconds", 1.5, { storage: "s3" });
+ * ```
+ */
+declare const recordHistogram: (name: string, value: number, attributes?: Record<string, string | number | boolean>) => Effect.Effect<void, never, OtelMeter>;
+/**
+ * Creates an observable gauge that reports the current value.
+ *
+ * @param name - Gauge name
+ * @param callback - Function that returns the current value
+ * @param attributes - Optional metric attributes
+ * @returns Effect that registers the gauge
+ *
+ * @example
+ * ```typescript
+ * let activeUploads = 0;
+ * yield* createGauge("active_uploads", () => activeUploads);
+ * ```
+ */
+declare const createGauge: (name: string, callback: () => number, attributes?: Record<string, string | number | boolean>) => Effect.Effect<void, never, OtelMeter>;
+//#endregion
+//#region src/core/logs-sdk.d.ts
+/**
+ * OpenTelemetry Logger service for emitting logs.
+ */
+interface OtelLoggerService {
+  /** The OpenTelemetry Logger instance */
+  readonly logger: Logger$1;
+  /** The LoggerProvider for shutdown handling */
+  readonly provider: LoggerProvider$1;
+}
+declare const OtelLogger_base: Context.TagClass<OtelLogger, "OtelLogger", OtelLoggerService>;
+/**
+ * Effect Context tag for the OTEL Logger service.
+ */
+declare class OtelLogger extends OtelLogger_base {}
+/**
+ * Maps Effect log levels to OpenTelemetry SeverityNumber.
+ *
+ * | Effect Level | OTEL Severity |
+ * |--------------|---------------|
+ * | Debug        | 5 (DEBUG)     |
+ * | Info         | 9 (INFO)      |
+ * | Warning      | 13 (WARN)     |
+ * | Error        | 17 (ERROR)    |
+ * | Fatal        | 21 (FATAL)    |
+ */
+declare function mapLogLevelToSeverity(level: string): SeverityNumber$1;
+/**
+ * Maps SeverityNumber to human-readable severity text.
+ */
+declare function severityToText(severity: SeverityNumber$1): string;
+/**
+ * Gets the current trace context from OpenTelemetry.
+ *
+ * @returns Object with trace_id and span_id if active, empty object otherwise
+ */
+declare function getTraceContext(): Record<string, string>;
+/**
+ * Extended configuration for logs SDK.
+ */
+interface LogsLayerConfig extends LogsSdkConfig {
+  /** Minimum severity level to export. Logs below this level are filtered. */
+  minSeverity?: SeverityNumber$1;
+}
+/**
+ * Node.js OTLP Logs SDK Layer for production use.
+ *
+ * Exports logs to an OTLP-compatible endpoint with automatic trace correlation.
+ *
+ * @example
+ * ```typescript
+ * import { OtlpLogsNodeSdkLive, OtelLogger } from "@uploadista/observability";
+ * import { Effect } from "effect";
+ * import { SeverityNumber } from "@opentelemetry/api-logs";
+ *
+ * const program = Effect.gen(function* () {
+ *   const { logger } = yield* OtelLogger;
+ *   logger.emit({
+ *     severityNumber: SeverityNumber.INFO,
+ *     body: "Upload completed",
+ *     attributes: { uploadId: "123" },
+ *   });
+ * }).pipe(Effect.provide(OtlpLogsNodeSdkLive));
+ * ```
+ */
+declare const OtlpLogsNodeSdkLive: Layer.Layer<OtelLogger, never, never>;
+/**
+ * Creates a customized OTLP Logs Node.js SDK Layer.
+ *
+ * @param config - Custom configuration options
+ * @returns Configured Effect Layer
+ *
+ * @example
+ * ```typescript
+ * const customLogs = createOtlpLogsNodeSdkLayer({
+ *   serviceName: "my-upload-service",
+ *   minSeverity: SeverityNumber.WARN, // Only export WARN and above
+ * });
+ * ```
+ */
+declare function createOtlpLogsNodeSdkLayer(config?: LogsLayerConfig): Layer.Layer<OtelLogger, never, never>;
+/**
+ * Browser OTLP Logs SDK Layer for production use.
+ *
+ * Uses the same OTLP HTTP exporter, suitable for browser environments.
+ * Note: Browser environments may have CORS restrictions.
+ *
+ * @example
+ * ```typescript
+ * import { OtlpLogsWebSdkLive } from "@uploadista/observability";
+ *
+ * const program = myEffect.pipe(Effect.provide(OtlpLogsWebSdkLive));
+ * ```
+ */
+declare const OtlpLogsWebSdkLive: Layer.Layer<OtelLogger, never, never>;
+/**
+ * Creates a customized OTLP Logs Web SDK Layer.
+ *
+ * @param config - Custom configuration options
+ * @returns Configured Effect Layer for browser environments
+ */
+declare function createOtlpLogsWebSdkLayer(config?: LogsLayerConfig): Layer.Layer<OtelLogger, never, never>;
+/**
+ * Cloudflare Workers OTLP Logs SDK Layer for production use.
+ *
+ * Pre-configured with Workers-appropriate defaults.
+ *
+ * @example
+ * ```typescript
+ * import { OtlpLogsWorkersSdkLive } from "@uploadista/observability";
+ *
+ * export default {
+ *   async fetch(request, env) {
+ *     const program = handleRequest(request).pipe(
+ *       Effect.provide(OtlpLogsWorkersSdkLive)
+ *     );
+ *     return Effect.runPromise(program);
+ *   }
+ * };
+ * ```
+ */
+declare const OtlpLogsWorkersSdkLive: Layer.Layer<OtelLogger, never, never>;
+/**
+ * Creates a customized OTLP Logs Workers SDK Layer.
+ *
+ * @param config - Custom configuration options
+ * @returns Configured Effect Layer for Cloudflare Workers
+ */
+declare function createOtlpLogsWorkersSdkLayer(config?: LogsLayerConfig): Layer.Layer<OtelLogger, never, never>;
+/**
+ * Creates an Effect Logger that forwards logs to OTLP.
+ *
+ * This logger intercepts Effect.log calls and sends them to the OTLP endpoint
+ * with automatic trace correlation and annotation support.
+ *
+ * @param minSeverity - Minimum severity to export (default: all)
+ * @returns Effect Logger that exports to OTLP
+ *
+ * @example
+ * ```typescript
+ * import { createOtlpEffectLogger, OtlpLogsNodeSdkLive } from "@uploadista/observability";
+ *
+ * const program = Effect.gen(function* () {
+ *   yield* Effect.log("This will be exported to OTLP");
+ *   yield* Effect.logError("Errors too!");
+ * }).pipe(
+ *   Effect.provide(OtlpLogsNodeSdkLive),
+ *   EffectLogger.withMinimumLogLevel(LogLevel.Debug),
+ * );
+ * ```
+ */
+declare const createOtlpEffectLogger: (minSeverity?: SeverityNumber$1) => Logger.Logger<unknown, void>;
+/**
+ * Emits a log record to OTLP using the OtelLogger from context.
+ *
+ * @param level - Log level (debug, info, warn, error, fatal)
+ * @param message - Log message
+ * @param attributes - Optional log attributes
+ * @returns Effect that emits the log
+ *
+ * @example
+ * ```typescript
+ * yield* emitLog("info", "Upload completed", { uploadId: "123" });
+ * ```
+ */
+declare const emitLog: (level: "debug" | "info" | "warn" | "error" | "fatal", message: string, attributes?: Record<string, string | number | boolean>) => Effect.Effect<void, never, OtelLogger>;
+/**
+ * Emits a debug log to OTLP.
+ */
+declare const logDebug: (message: string, attributes?: Record<string, string | number | boolean>) => Effect.Effect<void, never, OtelLogger>;
+/**
+ * Emits an info log to OTLP.
+ */
+declare const logInfo: (message: string, attributes?: Record<string, string | number | boolean>) => Effect.Effect<void, never, OtelLogger>;
+/**
+ * Emits a warning log to OTLP.
+ */
+declare const logWarn: (message: string, attributes?: Record<string, string | number | boolean>) => Effect.Effect<void, never, OtelLogger>;
+/**
+ * Emits an error log to OTLP.
+ */
+declare const logError: (message: string, attributes?: Record<string, string | number | boolean>) => Effect.Effect<void, never, OtelLogger>;
+/**
+ * Emits a fatal log to OTLP.
+ */
+declare const logFatal: (message: string, attributes?: Record<string, string | number | boolean>) => Effect.Effect<void, never, OtelLogger>;
+//#endregion
+//#region src/core/types.d.ts
+/**
+ * OpenTelemetry trace context types for distributed tracing.
+ *
+ * These types enable trace context propagation across HTTP requests,
+ * allowing spans from multiple requests to be grouped under a single trace.
+ *
+ * @module observability/core/types
+ */
+/**
+ * Trace context for distributed tracing.
+ *
+ * This structure holds the essential OpenTelemetry trace context that needs
+ * to be persisted and propagated across requests to maintain trace continuity.
+ *
+ * @property traceId - 128-bit unique identifier for the entire trace (32 hex chars)
+ * @property spanId - 64-bit unique identifier for the parent span (16 hex chars)
+ * @property traceFlags - Sampling decision (1 = sampled, 0 = not sampled)
+ *
+ * @example
+ * ```typescript
+ * // Store trace context with upload metadata
+ * const traceContext: TraceContext = {
+ *   traceId: "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4",
+ *   spanId: "a1b2c3d4e5f6a1b2",
+ *   traceFlags: 1
+ * };
+ *
+ * // Later, restore context to link spans
+ * if (uploadFile.traceContext) {
+ *   yield* withParentContext(uploadFile.traceContext)(
+ *     Effect.withSpan("upload-chunk", { ... })(chunkEffect)
+ *   );
+ * }
+ * ```
+ */
+type TraceContext = {
+  /** 128-bit trace identifier (32 hex characters) */
+  traceId: string;
+  /** 64-bit span identifier (16 hex characters) */
+  spanId: string;
+  /** Trace flags (1 = sampled) */
+  traceFlags: number;
+};
+//#endregion
+//#region src/core/tracing.d.ts
+declare const TracingService: Context.Tag<{
+  serviceName: string;
+}, {
+  serviceName: string;
+}>;
+declare const createTracingLayer: (options?: {
+  serviceName?: string;
+}) => Layer.Layer<{
+  serviceName: string;
+}, never, never>;
+declare const createStorageTracingLayer: (storageType: string) => Layer.Layer<{
+  serviceName: string;
+}, never, never>;
+declare const withStorageSpan: <A, E, R>(operation: string, storageType: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan>>;
+declare const WebSdkLive: Layer.Layer<_effect_opentelemetry_Resource7.Resource, never, never>;
+declare const NodeSdkLive: Layer.Layer<_effect_opentelemetry_Resource7.Resource, never, never>;
+declare const WorkersSdkLive: Layer.Layer<_effect_opentelemetry_Resource7.Resource, never, never>;
+/**
+ * Configuration options for OTLP SDK layers.
+ */
+interface OtlpSdkConfig {
+  /** Service name for traces. Defaults to OTEL_SERVICE_NAME or "uploadista" */
+  serviceName?: string;
+  /** Additional resource attributes to include in all spans */
+  resourceAttributes?: Record<string, string>;
+  /** Maximum queue size for batch processor. Defaults to 512 */
+  maxQueueSize?: number;
+  /** Maximum export batch size. Defaults to 512 */
+  maxExportBatchSize?: number;
+  /** Schedule delay in milliseconds. Defaults to 5000 */
+  scheduledDelayMillis?: number;
+  /** Export timeout in milliseconds. Defaults to 5000 */
+  exportTimeoutMillis?: number;
+}
+/**
+ * Node.js OTLP SDK Layer for production use.
+ *
+ * Exports traces to an OTLP-compatible endpoint configured via environment variables:
+ * - OTEL_EXPORTER_OTLP_ENDPOINT: Base endpoint (default: http://localhost:4318)
+ * - OTEL_EXPORTER_OTLP_HEADERS: Authentication headers
+ * - OTEL_SERVICE_NAME: Service name (default: uploadista)
+ * - OTEL_RESOURCE_ATTRIBUTES: Additional resource attributes
+ * - UPLOADISTA_OBSERVABILITY_ENABLED: Set to "false" to disable (default: true)
+ *
+ * @example
+ * ```typescript
+ * import { OtlpNodeSdkLive } from "@uploadista/observability";
+ * import { Effect } from "effect";
+ *
+ * // With default environment configuration
+ * const program = myEffect.pipe(Effect.provide(OtlpNodeSdkLive));
+ *
+ * // Run with:
+ * // OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
+ * // OTEL_SERVICE_NAME=my-upload-service
+ * ```
+ */
+declare const OtlpNodeSdkLive: Layer.Layer<_effect_opentelemetry_Resource7.Resource, never, never>;
+/**
+ * Creates a customized OTLP Node.js SDK Layer.
+ *
+ * Use this when you need to customize the SDK configuration beyond
+ * what environment variables provide.
+ *
+ * @param config - Custom configuration options
+ * @returns Configured Effect Layer
+ *
+ * @example
+ * ```typescript
+ * const customSdk = createOtlpNodeSdkLayer({
+ *   serviceName: "my-custom-service",
+ *   resourceAttributes: {
+ *     "tenant.id": "abc123",
+ *     "deployment.environment": "production"
+ *   },
+ *   maxQueueSize: 1024,
+ * });
+ *
+ * const program = myEffect.pipe(Effect.provide(customSdk));
+ * ```
+ */
+declare function createOtlpNodeSdkLayer(config?: OtlpSdkConfig): Layer.Layer<_effect_opentelemetry_Resource7.Resource, never, never>;
+/**
+ * Browser OTLP SDK Layer for production use.
+ *
+ * Similar to OtlpNodeSdkLive but uses fetch API for browser compatibility.
+ * Note: Browser environments may have CORS restrictions.
+ *
+ * @example
+ * ```typescript
+ * import { OtlpWebSdkLive } from "@uploadista/observability";
+ *
+ * const program = myEffect.pipe(Effect.provide(OtlpWebSdkLive));
+ * ```
+ */
+declare const OtlpWebSdkLive: Layer.Layer<_effect_opentelemetry_Resource7.Resource, never, never>;
+/**
+ * Creates a customized OTLP Web SDK Layer.
+ *
+ * @param config - Custom configuration options
+ * @returns Configured Effect Layer for browser environments
+ */
+declare function createOtlpWebSdkLayer(config?: OtlpSdkConfig): Layer.Layer<_effect_opentelemetry_Resource7.Resource, never, never>;
+/**
+ * Cloudflare Workers OTLP SDK Layer for production use.
+ *
+ * Uses the Web SDK under the hood with fetch-based export.
+ * Suitable for edge computing environments.
+ *
+ * @example
+ * ```typescript
+ * import { OtlpWorkersSdkLive } from "@uploadista/observability";
+ *
+ * export default {
+ *   async fetch(request, env) {
+ *     const program = handleRequest(request).pipe(
+ *       Effect.provide(OtlpWorkersSdkLive)
+ *     );
+ *     return Effect.runPromise(program);
+ *   }
+ * };
+ * ```
+ */
+declare const OtlpWorkersSdkLive: Layer.Layer<_effect_opentelemetry_Resource7.Resource, never, never>;
+/**
+ * Creates a customized OTLP Workers SDK Layer.
+ *
+ * @param config - Custom configuration options
+ * @returns Configured Effect Layer for Cloudflare Workers
+ */
+declare function createOtlpWorkersSdkLayer(config?: OtlpSdkConfig): Layer.Layer<_effect_opentelemetry_Resource7.Resource, never, never>;
+/**
+ * @deprecated Use `captureTraceContextEffect` instead. This synchronous function
+ * uses OpenTelemetry's `trace.getActiveSpan()` which may not be synchronized
+ * with Effect's span context when using @effect/opentelemetry.
+ *
+ * @returns TraceContext if there's an active OpenTelemetry span, undefined otherwise
+ */
+declare function captureTraceContext(): TraceContext | undefined;
+/**
+ * Captures the current Effect trace context for distributed tracing.
+ *
+ * Uses Effect's `currentSpan` to get the active span, which is more reliable
+ * than OpenTelemetry's `trace.getActiveSpan()` when using @effect/opentelemetry
+ * because Effect manages its own span context that may not be synchronized
+ * with OpenTelemetry's global context.
+ *
+ * Use this to save the trace context (traceId, spanId, traceFlags) for later
+ * use in distributed tracing. The captured context can be stored alongside
+ * data (e.g., in KV store with upload metadata) and restored later using
+ * `createExternalSpan` and passing it to `Effect.withSpan`'s `parent` option.
+ *
+ * @returns Effect yielding TraceContext if there's an active span, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * // Capture context during upload creation
+ * const createUpload = Effect.gen(function* () {
+ *   const traceContext = yield* captureTraceContextEffect;
+ *
+ *   const file: UploadFile = {
+ *     id: uploadId,
+ *     traceContext, // Store for later
+ *     // ...
+ *   };
+ *   yield* kvStore.set(uploadId, file);
+ * }).pipe(Effect.withSpan("upload-create", { ... }));
+ * ```
+ */
+declare const captureTraceContextEffect: Effect.Effect<TraceContext | undefined>;
+/**
+ * Creates an ExternalSpan from a stored trace context.
+ *
+ * Use this to create a parent span reference that can be passed to
+ * `Effect.withSpan`'s `parent` option for distributed tracing.
+ *
+ * **Important:** The parent must be passed directly to `Effect.withSpan`'s
+ * options, not provided as a service afterward.
+ *
+ * @param traceContext - Previously captured trace context
+ * @returns ExternalSpan that can be used as a parent in Effect.withSpan
+ *
+ * @example
+ * ```typescript
+ * // Create parent span from stored trace context
+ * const parentSpan = file.traceContext
+ *   ? createExternalSpan(file.traceContext)
+ *   : undefined;
+ *
+ * // Pass parent directly to withSpan
+ * const chunkEffect = Effect.gen(function* () {
+ *   // ... chunk upload logic
+ * }).pipe(
+ *   Effect.withSpan("upload-chunk", {
+ *     attributes: { ... },
+ *     parent: parentSpan,  // Link to original trace
+ *   })
+ * );
+ * ```
+ */
+declare function createExternalSpan(traceContext: TraceContext): Tracer.ExternalSpan;
+/**
+ * @deprecated Use `createExternalSpan` instead and pass the result to
+ * `Effect.withSpan`'s `parent` option directly. This function doesn't
+ * work correctly because Effect.withSpan reads the parent at construction
+ * time, not from the provided service.
+ *
+ * @example
+ * ```typescript
+ * // Instead of:
+ * withParentContext(traceContext)(effect.pipe(Effect.withSpan(...)))
+ *
+ * // Do this:
+ * const parent = createExternalSpan(traceContext);
+ * effect.pipe(Effect.withSpan("name", { parent }))
+ * ```
+ */
+declare function withParentContext(traceContext: TraceContext): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Checks if there's an active trace context.
+ *
+ * Useful for conditional logic based on whether tracing is active.
+ *
+ * @returns true if there's an active span with valid trace context
+ *
+ * @example
+ * ```typescript
+ * if (hasActiveTraceContext()) {
+ *   console.log("Tracing is active");
+ * }
+ * ```
+ */
+declare function hasActiveTraceContext(): boolean;
+//#endregion
+//#region src/core/full-observability.d.ts
+/**
+ * Configuration for full observability SDK.
+ */
+interface FullObservabilityConfig {
+  /** Service name for all telemetry. Defaults to OTEL_SERVICE_NAME or "uploadista" */
+  serviceName?: string;
+  /** Additional resource attributes */
+  resourceAttributes?: Record<string, string>;
+  /** Traces-specific configuration */
+  traces?: Omit<OtlpSdkConfig, "serviceName" | "resourceAttributes">;
+  /** Metrics-specific configuration */
+  metrics?: Omit<MetricsSdkConfig, "serviceName">;
+  /** Logs-specific configuration */
+  logs?: Omit<LogsLayerConfig, "serviceName">;
+}
+/**
+ * Node.js Full Observability SDK Layer.
+ *
+ * Combines traces, metrics, and logs export into a single layer.
+ * Use this for easy setup of complete observability.
+ *
+ * @example
+ * ```typescript
+ * import { OtlpFullObservabilityNodeSdkLive } from "@uploadista/observability";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   // All three pillars are now active:
+ *   // - Traces via Effect.withSpan
+ *   // - Metrics via OtelMeter
+ *   // - Logs via OtelLogger
+ *   yield* Effect.log("This goes to OTLP!");
+ * }).pipe(Effect.provide(OtlpFullObservabilityNodeSdkLive));
+ * ```
+ */
+declare const OtlpFullObservabilityNodeSdkLive: Layer.Layer<_effect_opentelemetry_Resource7.Resource | OtelMeter | OtelLogger, never, never>;
+/**
+ * Creates a customized Full Observability Node.js SDK Layer.
+ *
+ * @param config - Configuration for all three pillars
+ * @returns Combined Effect Layer
+ *
+ * @example
+ * ```typescript
+ * const customObservability = createOtlpFullObservabilityNodeSdkLayer({
+ *   serviceName: "my-upload-service",
+ *   traces: { maxQueueSize: 1024 },
+ *   metrics: { exportIntervalMillis: 30000 },
+ *   logs: { minSeverity: SeverityNumber.WARN },
+ * });
+ * ```
+ */
+declare function createOtlpFullObservabilityNodeSdkLayer(config?: FullObservabilityConfig): Layer.Layer<_effect_opentelemetry_Resource7.Resource | OtelMeter | OtelLogger, never, never>;
+/**
+ * Browser Full Observability SDK Layer.
+ *
+ * Combines traces, metrics, and logs export for browser environments.
+ *
+ * @example
+ * ```typescript
+ * import { OtlpFullObservabilityWebSdkLive } from "@uploadista/observability";
+ *
+ * const program = myEffect.pipe(Effect.provide(OtlpFullObservabilityWebSdkLive));
+ * ```
+ */
+declare const OtlpFullObservabilityWebSdkLive: Layer.Layer<_effect_opentelemetry_Resource7.Resource | OtelMeter | OtelLogger, never, never>;
+/**
+ * Creates a customized Full Observability Web SDK Layer.
+ *
+ * @param config - Configuration for all three pillars
+ * @returns Combined Effect Layer for browser environments
+ */
+declare function createOtlpFullObservabilityWebSdkLayer(config?: FullObservabilityConfig): Layer.Layer<_effect_opentelemetry_Resource7.Resource | OtelMeter | OtelLogger, never, never>;
+/**
+ * Cloudflare Workers Full Observability SDK Layer.
+ *
+ * Combines traces, metrics, and logs export for Workers environments.
+ *
+ * @example
+ * ```typescript
+ * import { OtlpFullObservabilityWorkersSdkLive } from "@uploadista/observability";
+ *
+ * export default {
+ *   async fetch(request, env) {
+ *     const program = handleRequest(request).pipe(
+ *       Effect.provide(OtlpFullObservabilityWorkersSdkLive)
+ *     );
+ *     return Effect.runPromise(program);
+ *   }
+ * };
+ * ```
+ */
+declare const OtlpFullObservabilityWorkersSdkLive: Layer.Layer<_effect_opentelemetry_Resource7.Resource | OtelMeter | OtelLogger, never, never>;
+/**
+ * Creates a customized Full Observability Workers SDK Layer.
+ *
+ * @param config - Configuration for all three pillars
+ * @returns Combined Effect Layer for Cloudflare Workers
+ */
+declare function createOtlpFullObservabilityWorkersSdkLayer(config?: FullObservabilityConfig): Layer.Layer<_effect_opentelemetry_Resource7.Resource | OtelMeter | OtelLogger, never, never>;
+/**
+ * Runtime environment types.
+ */
+type Environment = "node" | "web" | "workers";
+/**
+ * Detects the current runtime environment.
+ *
+ * @returns The detected environment
+ */
+declare function detectEnvironment(): Environment;
+/**
+ * Auto-detecting Full Observability SDK Layer.
+ *
+ * Automatically selects the appropriate layer based on runtime environment.
+ *
+ * @example
+ * ```typescript
+ * import { OtlpAutoSdkLive } from "@uploadista/observability";
+ *
+ * // Works in Node.js, Browser, or Workers automatically
+ * const program = myEffect.pipe(Effect.provide(OtlpAutoSdkLive));
+ * ```
+ */
+declare const OtlpAutoSdkLive: Layer.Layer<_effect_opentelemetry_Resource7.Resource | OtelMeter | OtelLogger, never, never>;
+/**
+ * Creates an auto-detecting Full Observability SDK Layer with custom config.
+ *
+ * @param config - Configuration for all three pillars
+ * @returns Auto-detecting combined Effect Layer
+ */
+declare function createOtlpAutoSdkLayer(config?: FullObservabilityConfig): Layer.Layer<_effect_opentelemetry_Resource7.Resource | OtelMeter | OtelLogger, never, never>;
+//#endregion
 //#region src/core/layers.d.ts
 /**
  * Core observability service providing tracing, metrics, and logging capabilities
@@ -207,25 +1160,6 @@ declare const createTestFixture: (storageType?: string) => ObservabilityTestFixt
  */
 declare const runWithTestObservability: <A, E>(effect: Effect.Effect<A, E, StorageObservability | UploadObservability | FlowObservability>, storageType?: string) => Effect.Effect<A, E>;
 //#endregion
-//#region src/core/tracing.d.ts
-declare const TracingService: Context.Tag<{
-  serviceName: string;
-}, {
-  serviceName: string;
-}>;
-declare const createTracingLayer: (options?: {
-  serviceName?: string;
-}) => Layer.Layer<{
-  serviceName: string;
-}, never, never>;
-declare const createStorageTracingLayer: (storageType: string) => Layer.Layer<{
-  serviceName: string;
-}, never, never>;
-declare const withStorageSpan: <A, E, R>(operation: string, storageType: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, effect_Tracer0.ParentSpan>>;
-declare const WebSdkLive: Layer.Layer<_effect_opentelemetry_Resource0.Resource, never, never>;
-declare const NodeSdkLive: Layer.Layer<_effect_opentelemetry_Resource0.Resource, never, never>;
-declare const WorkersSdkLive: Layer.Layer<_effect_opentelemetry_Resource0.Resource, never, never>;
-//#endregion
 //#region src/core/utilities.d.ts
 declare const withUploadMetrics: <A, E, R>(metrics: StorageMetrics, uploadId: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 declare const withApiMetrics: <A, E, R>(metrics: StorageMetrics, operation: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
@@ -275,8 +1209,12 @@ declare const getFlowMetrics: Effect.Effect<{
 declare const withFlowDuration: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 /**
  * Helper to track node duration
+ * @param nodeId - Unique node identifier
+ * @param nodeType - Generic node type (e.g., "optimize", "resize")
+ * @param effect - The effect to track
+ * @param nodeTypeId - Optional specific node type ID (e.g., "optimize-image", "resize-video")
  */
-declare const withNodeDuration: <A, E, R>(nodeId: string, nodeType: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withNodeDuration: <A, E, R>(nodeId: string, nodeType: string, effect: Effect.Effect<A, E, R>, nodeTypeId?: string) => Effect.Effect<A, E, R>;
 /**
  * Helper to track active flows
  */
@@ -406,6 +1344,42 @@ declare const withExecutionContext: (context: {
   totalNodes?: number;
   parallelCount?: number;
 }) => Effect.Effect<void, never, never>;
+/**
+ * Operation domains for plugin-level tracing
+ */
+type OperationDomain = "image" | "video" | "document" | "ai" | "virus-scan" | "zip";
+/**
+ * Wrap an Effect with a plugin operation span
+ *
+ * @param domain - The operation domain (e.g., "image", "video", "document")
+ * @param operation - The specific operation (e.g., "optimize", "transcode", "extract-text")
+ * @param attributes - Optional span attributes with operation-specific details
+ *
+ * @example
+ * ```typescript
+ * // Image optimization span
+ * withOperationSpan("image", "optimize", {
+ *   "image.format": "webp",
+ *   "image.quality": 80,
+ * })(imageService.optimize(inputBytes, params))
+ *
+ * // Video transcoding span
+ * withOperationSpan("video", "transcode", {
+ *   "video.format": "mp4",
+ *   "video.codec": "h264",
+ * })(videoService.transcode(inputBytes, params))
+ * ```
+ */
+declare const withOperationSpan: <A, E, R>(domain: OperationDomain, operation: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Add operation context to the current span
+ */
+declare const withOperationContext: (context: {
+  domain: OperationDomain;
+  operation: string;
+  inputSize?: number;
+  outputSize?: number;
+}) => Effect.Effect<void, never, never>;
 /**
  * Circuit breaker state for tracing
  */
@@ -459,18 +1433,18 @@ declare const NoOpMetricsServiceLive: Layer.Layer<MetricsService>;
 //#endregion
 //#region src/storage/azure.d.ts
 declare const azureMetrics: {
-  uploadLatencySummary: effect_Metric24.Metric.Summary<number>;
-  activeUploadsGauge: effect_Metric24.Metric.Gauge<number>;
-  uploadThroughputGauge: effect_Metric24.Metric.Gauge<number>;
-  uploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  partUploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  fileSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  partSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  uploadRequestsTotal: effect_Metric24.Metric.Counter<number>;
-  uploadPartsTotal: effect_Metric24.Metric.Counter<number>;
-  uploadSuccessTotal: effect_Metric24.Metric.Counter<number>;
-  uploadErrorsTotal: effect_Metric24.Metric.Counter<number>;
-  apiCallsTotal: effect_Metric24.Metric.Counter<number>;
+  uploadLatencySummary: effect_Metric49.Metric.Summary<number>;
+  activeUploadsGauge: effect_Metric49.Metric.Gauge<number>;
+  uploadThroughputGauge: effect_Metric49.Metric.Gauge<number>;
+  uploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  partUploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  fileSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  partSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  uploadRequestsTotal: effect_Metric49.Metric.Counter<number>;
+  uploadPartsTotal: effect_Metric49.Metric.Counter<number>;
+  uploadSuccessTotal: effect_Metric49.Metric.Counter<number>;
+  uploadErrorsTotal: effect_Metric49.Metric.Counter<number>;
+  apiCallsTotal: effect_Metric49.Metric.Counter<number>;
 };
 declare const AzureTracingLayer: Layer.Layer<{
   serviceName: string;
@@ -481,7 +1455,7 @@ declare const AzureObservabilityLayer: Layer.Layer<{
 }, never, never>;
 declare const withAzureUploadMetrics: <A, E, R>(uploadId: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 declare const withAzureApiMetrics: <A, E, R>(operation: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-declare const withAzureTimingMetrics: <A, E, R>(metric: effect_Metric24.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withAzureTimingMetrics: <A, E, R>(metric: effect_Metric49.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 declare const withAzureOperationMetrics: <A, E, R>(operation: string, uploadId: string, effect: Effect.Effect<A, E, R>, fileSize?: number) => Effect.Effect<A, E, R>;
 declare const withAzureSpan: <A, E, R>(operation: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<unknown, unknown, unknown>;
 declare const logAzureOperation: (operation: string, uploadId: string, metadata?: Record<string, unknown> | undefined) => Effect.Effect<void, never, never>;
@@ -500,23 +1474,23 @@ declare const logAzureUploadCompletion: (uploadId: string, metrics: {
   retryCount?: number;
 }) => Effect.Effect<void, never, never>;
 declare const logAzureContext: (message: string, context: Record<string, unknown>) => Effect.Effect<void, never, never>;
-declare const azureUploadRequestsTotal: effect_Metric24.Metric.Counter<number>, azureUploadPartsTotal: effect_Metric24.Metric.Counter<number>, azureUploadSuccessTotal: effect_Metric24.Metric.Counter<number>, azureUploadErrorsTotal: effect_Metric24.Metric.Counter<number>, azureApiCallsTotal: effect_Metric24.Metric.Counter<number>, azureUploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, azurePartUploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, azureFileSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, azurePartSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, azureActiveUploadsGauge: effect_Metric24.Metric.Gauge<number>, azureUploadThroughputGauge: effect_Metric24.Metric.Gauge<number>, azureUploadLatencySummary: effect_Metric24.Metric.Summary<number>;
+declare const azureUploadRequestsTotal: effect_Metric49.Metric.Counter<number>, azureUploadPartsTotal: effect_Metric49.Metric.Counter<number>, azureUploadSuccessTotal: effect_Metric49.Metric.Counter<number>, azureUploadErrorsTotal: effect_Metric49.Metric.Counter<number>, azureApiCallsTotal: effect_Metric49.Metric.Counter<number>, azureUploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, azurePartUploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, azureFileSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, azurePartSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, azureActiveUploadsGauge: effect_Metric49.Metric.Gauge<number>, azureUploadThroughputGauge: effect_Metric49.Metric.Gauge<number>, azureUploadLatencySummary: effect_Metric49.Metric.Summary<number>;
 type AzureMetrics = StorageMetrics;
 //#endregion
 //#region src/storage/filesystem.d.ts
 declare const filesystemMetrics: {
-  uploadLatencySummary: effect_Metric24.Metric.Summary<number>;
-  activeUploadsGauge: effect_Metric24.Metric.Gauge<number>;
-  uploadThroughputGauge: effect_Metric24.Metric.Gauge<number>;
-  uploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  partUploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  fileSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  partSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  uploadRequestsTotal: effect_Metric24.Metric.Counter<number>;
-  uploadPartsTotal: effect_Metric24.Metric.Counter<number>;
-  uploadSuccessTotal: effect_Metric24.Metric.Counter<number>;
-  uploadErrorsTotal: effect_Metric24.Metric.Counter<number>;
-  apiCallsTotal: effect_Metric24.Metric.Counter<number>;
+  uploadLatencySummary: effect_Metric49.Metric.Summary<number>;
+  activeUploadsGauge: effect_Metric49.Metric.Gauge<number>;
+  uploadThroughputGauge: effect_Metric49.Metric.Gauge<number>;
+  uploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  partUploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  fileSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  partSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  uploadRequestsTotal: effect_Metric49.Metric.Counter<number>;
+  uploadPartsTotal: effect_Metric49.Metric.Counter<number>;
+  uploadSuccessTotal: effect_Metric49.Metric.Counter<number>;
+  uploadErrorsTotal: effect_Metric49.Metric.Counter<number>;
+  apiCallsTotal: effect_Metric49.Metric.Counter<number>;
 };
 declare const FilesystemTracingLayer: Layer.Layer<{
   serviceName: string;
@@ -527,7 +1501,7 @@ declare const FilesystemObservabilityLayer: Layer.Layer<{
 }, never, never>;
 declare const withFilesystemUploadMetrics: <A, E, R>(uploadId: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 declare const withFilesystemApiMetrics: <A, E, R>(operation: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-declare const withFilesystemTimingMetrics: <A, E, R>(metric: effect_Metric24.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withFilesystemTimingMetrics: <A, E, R>(metric: effect_Metric49.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 declare const withFilesystemOperationMetrics: <A, E, R>(operation: string, uploadId: string, effect: Effect.Effect<A, E, R>, fileSize?: number) => Effect.Effect<A, E, R>;
 declare const withFilesystemSpan: <A, E, R>(operation: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<unknown, unknown, unknown>;
 declare const logFilesystemOperation: (operation: string, uploadId: string, metadata?: Record<string, unknown> | undefined) => Effect.Effect<void, never, never>;
@@ -546,23 +1520,23 @@ declare const logFilesystemUploadCompletion: (uploadId: string, metrics: {
   retryCount?: number;
 }) => Effect.Effect<void, never, never>;
 declare const logFilesystemContext: (message: string, context: Record<string, unknown>) => Effect.Effect<void, never, never>;
-declare const filesystemUploadRequestsTotal: effect_Metric24.Metric.Counter<number>, filesystemUploadPartsTotal: effect_Metric24.Metric.Counter<number>, filesystemUploadSuccessTotal: effect_Metric24.Metric.Counter<number>, filesystemUploadErrorsTotal: effect_Metric24.Metric.Counter<number>, filesystemApiCallsTotal: effect_Metric24.Metric.Counter<number>, filesystemUploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, filesystemPartUploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, filesystemFileSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, filesystemPartSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, filesystemActiveUploadsGauge: effect_Metric24.Metric.Gauge<number>, filesystemUploadThroughputGauge: effect_Metric24.Metric.Gauge<number>, filesystemUploadLatencySummary: effect_Metric24.Metric.Summary<number>;
+declare const filesystemUploadRequestsTotal: effect_Metric49.Metric.Counter<number>, filesystemUploadPartsTotal: effect_Metric49.Metric.Counter<number>, filesystemUploadSuccessTotal: effect_Metric49.Metric.Counter<number>, filesystemUploadErrorsTotal: effect_Metric49.Metric.Counter<number>, filesystemApiCallsTotal: effect_Metric49.Metric.Counter<number>, filesystemUploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, filesystemPartUploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, filesystemFileSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, filesystemPartSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, filesystemActiveUploadsGauge: effect_Metric49.Metric.Gauge<number>, filesystemUploadThroughputGauge: effect_Metric49.Metric.Gauge<number>, filesystemUploadLatencySummary: effect_Metric49.Metric.Summary<number>;
 type FilesystemMetrics = StorageMetrics;
 //#endregion
 //#region src/storage/gcs.d.ts
 declare const gcsMetrics: {
-  uploadLatencySummary: effect_Metric24.Metric.Summary<number>;
-  activeUploadsGauge: effect_Metric24.Metric.Gauge<number>;
-  uploadThroughputGauge: effect_Metric24.Metric.Gauge<number>;
-  uploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  partUploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  fileSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  partSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  uploadRequestsTotal: effect_Metric24.Metric.Counter<number>;
-  uploadPartsTotal: effect_Metric24.Metric.Counter<number>;
-  uploadSuccessTotal: effect_Metric24.Metric.Counter<number>;
-  uploadErrorsTotal: effect_Metric24.Metric.Counter<number>;
-  apiCallsTotal: effect_Metric24.Metric.Counter<number>;
+  uploadLatencySummary: effect_Metric49.Metric.Summary<number>;
+  activeUploadsGauge: effect_Metric49.Metric.Gauge<number>;
+  uploadThroughputGauge: effect_Metric49.Metric.Gauge<number>;
+  uploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  partUploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  fileSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  partSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  uploadRequestsTotal: effect_Metric49.Metric.Counter<number>;
+  uploadPartsTotal: effect_Metric49.Metric.Counter<number>;
+  uploadSuccessTotal: effect_Metric49.Metric.Counter<number>;
+  uploadErrorsTotal: effect_Metric49.Metric.Counter<number>;
+  apiCallsTotal: effect_Metric49.Metric.Counter<number>;
 };
 declare const GCSTracingLayer: Layer.Layer<{
   serviceName: string;
@@ -573,7 +1547,7 @@ declare const GCSObservabilityLayer: Layer.Layer<{
 }, never, never>;
 declare const withGCSUploadMetrics: <A, E, R>(uploadId: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 declare const withGCSApiMetrics: <A, E, R>(operation: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-declare const withGCSTimingMetrics: <A, E, R>(metric: effect_Metric24.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withGCSTimingMetrics: <A, E, R>(metric: effect_Metric49.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 declare const withGCSOperationMetrics: <A, E, R>(operation: string, uploadId: string, effect: Effect.Effect<A, E, R>, fileSize?: number) => Effect.Effect<A, E, R>;
 declare const withGCSSpan: <A, E, R>(operation: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<unknown, unknown, unknown>;
 declare const logGCSOperation: (operation: string, uploadId: string, metadata?: Record<string, unknown> | undefined) => Effect.Effect<void, never, never>;
@@ -592,23 +1566,23 @@ declare const logGCSUploadCompletion: (uploadId: string, metrics: {
   retryCount?: number;
 }) => Effect.Effect<void, never, never>;
 declare const logGCSContext: (message: string, context: Record<string, unknown>) => Effect.Effect<void, never, never>;
-declare const gcsUploadRequestsTotal: effect_Metric24.Metric.Counter<number>, gcsUploadPartsTotal: effect_Metric24.Metric.Counter<number>, gcsUploadSuccessTotal: effect_Metric24.Metric.Counter<number>, gcsUploadErrorsTotal: effect_Metric24.Metric.Counter<number>, gcsApiCallsTotal: effect_Metric24.Metric.Counter<number>, gcsUploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, gcsPartUploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, gcsFileSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, gcsPartSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, gcsActiveUploadsGauge: effect_Metric24.Metric.Gauge<number>, gcsUploadThroughputGauge: effect_Metric24.Metric.Gauge<number>, gcsUploadLatencySummary: effect_Metric24.Metric.Summary<number>;
+declare const gcsUploadRequestsTotal: effect_Metric49.Metric.Counter<number>, gcsUploadPartsTotal: effect_Metric49.Metric.Counter<number>, gcsUploadSuccessTotal: effect_Metric49.Metric.Counter<number>, gcsUploadErrorsTotal: effect_Metric49.Metric.Counter<number>, gcsApiCallsTotal: effect_Metric49.Metric.Counter<number>, gcsUploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, gcsPartUploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, gcsFileSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, gcsPartSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, gcsActiveUploadsGauge: effect_Metric49.Metric.Gauge<number>, gcsUploadThroughputGauge: effect_Metric49.Metric.Gauge<number>, gcsUploadLatencySummary: effect_Metric49.Metric.Summary<number>;
 type GCSMetrics = StorageMetrics;
 //#endregion
 //#region src/storage/s3.d.ts
 declare const s3Metrics: {
-  uploadLatencySummary: effect_Metric24.Metric.Summary<number>;
-  activeUploadsGauge: effect_Metric24.Metric.Gauge<number>;
-  uploadThroughputGauge: effect_Metric24.Metric.Gauge<number>;
-  uploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  partUploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  fileSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  partSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  uploadRequestsTotal: effect_Metric24.Metric.Counter<number>;
-  uploadPartsTotal: effect_Metric24.Metric.Counter<number>;
-  uploadSuccessTotal: effect_Metric24.Metric.Counter<number>;
-  uploadErrorsTotal: effect_Metric24.Metric.Counter<number>;
-  apiCallsTotal: effect_Metric24.Metric.Counter<number>;
+  uploadLatencySummary: effect_Metric49.Metric.Summary<number>;
+  activeUploadsGauge: effect_Metric49.Metric.Gauge<number>;
+  uploadThroughputGauge: effect_Metric49.Metric.Gauge<number>;
+  uploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  partUploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  fileSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  partSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  uploadRequestsTotal: effect_Metric49.Metric.Counter<number>;
+  uploadPartsTotal: effect_Metric49.Metric.Counter<number>;
+  uploadSuccessTotal: effect_Metric49.Metric.Counter<number>;
+  uploadErrorsTotal: effect_Metric49.Metric.Counter<number>;
+  apiCallsTotal: effect_Metric49.Metric.Counter<number>;
 };
 declare const S3TracingLayer: Layer.Layer<{
   serviceName: string;
@@ -619,7 +1593,7 @@ declare const S3ObservabilityLayer: Layer.Layer<{
 }, never, never>;
 declare const withS3UploadMetrics: <A, E, R>(uploadId: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 declare const withS3ApiMetrics: <A, E, R>(operation: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-declare const withS3TimingMetrics: <A, E, R>(metric: effect_Metric24.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare const withS3TimingMetrics: <A, E, R>(metric: effect_Metric49.Metric.Histogram<number>, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
 declare const withS3OperationMetrics: <A, E, R>(operation: string, uploadId: string, effect: Effect.Effect<A, E, R>, fileSize?: number) => Effect.Effect<A, E, R>;
 declare const withS3Span: <A, E, R>(operation: string, attributes?: Record<string, unknown>) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<unknown, unknown, unknown>;
 declare const logS3Operation: (operation: string, uploadId: string, metadata?: Record<string, unknown> | undefined) => Effect.Effect<void, never, never>;
@@ -638,7 +1612,7 @@ declare const logS3UploadCompletion: (uploadId: string, metrics: {
   retryCount?: number;
 }) => Effect.Effect<void, never, never>;
 declare const logS3Context: (message: string, context: Record<string, unknown>) => Effect.Effect<void, never, never>;
-declare const s3UploadRequestsTotal: effect_Metric24.Metric.Counter<number>, s3UploadPartsTotal: effect_Metric24.Metric.Counter<number>, s3UploadSuccessTotal: effect_Metric24.Metric.Counter<number>, s3UploadErrorsTotal: effect_Metric24.Metric.Counter<number>, s3ApiCallsTotal: effect_Metric24.Metric.Counter<number>, s3UploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, s3PartUploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, s3FileSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, s3PartSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, s3ActiveUploadsGauge: effect_Metric24.Metric.Gauge<number>, s3UploadThroughputGauge: effect_Metric24.Metric.Gauge<number>, s3UploadLatencySummary: effect_Metric24.Metric.Summary<number>;
+declare const s3UploadRequestsTotal: effect_Metric49.Metric.Counter<number>, s3UploadPartsTotal: effect_Metric49.Metric.Counter<number>, s3UploadSuccessTotal: effect_Metric49.Metric.Counter<number>, s3UploadErrorsTotal: effect_Metric49.Metric.Counter<number>, s3ApiCallsTotal: effect_Metric49.Metric.Counter<number>, s3UploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, s3PartUploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, s3FileSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, s3PartSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>, s3ActiveUploadsGauge: effect_Metric49.Metric.Gauge<number>, s3UploadThroughputGauge: effect_Metric49.Metric.Gauge<number>, s3UploadLatencySummary: effect_Metric49.Metric.Summary<number>;
 type S3Metrics = StorageMetrics;
 //#endregion
 //#region src/upload/metrics.d.ts
@@ -739,21 +1713,21 @@ declare const UploadObservabilityTest: Layer.Layer<UploadObservability, never, n
  * Get metrics for validation (useful for testing metric definitions)
  */
 declare const getTestMetrics: () => {
-  uploadCreatedTotal: effect_Metric24.Metric.Counter<number>;
-  uploadCompletedTotal: effect_Metric24.Metric.Counter<number>;
-  uploadFailedTotal: effect_Metric24.Metric.Counter<number>;
-  chunkUploadedTotal: effect_Metric24.Metric.Counter<number>;
-  uploadFromUrlTotal: effect_Metric24.Metric.Counter<number>;
-  uploadFromUrlSuccessTotal: effect_Metric24.Metric.Counter<number>;
-  uploadFromUrlFailedTotal: effect_Metric24.Metric.Counter<number>;
-  uploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  chunkUploadDurationHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  uploadFileSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  chunkSizeHistogram: effect_Metric24.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
-  activeUploadsGauge: effect_Metric24.Metric.Gauge<number>;
-  uploadThroughputGauge: effect_Metric24.Metric.Gauge<number>;
-  uploadLatencySummary: effect_Metric24.Metric.Summary<number>;
-  chunkLatencySummary: effect_Metric24.Metric.Summary<number>;
+  uploadCreatedTotal: effect_Metric49.Metric.Counter<number>;
+  uploadCompletedTotal: effect_Metric49.Metric.Counter<number>;
+  uploadFailedTotal: effect_Metric49.Metric.Counter<number>;
+  chunkUploadedTotal: effect_Metric49.Metric.Counter<number>;
+  uploadFromUrlTotal: effect_Metric49.Metric.Counter<number>;
+  uploadFromUrlSuccessTotal: effect_Metric49.Metric.Counter<number>;
+  uploadFromUrlFailedTotal: effect_Metric49.Metric.Counter<number>;
+  uploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  chunkUploadDurationHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  uploadFileSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  chunkSizeHistogram: effect_Metric49.Metric<effect_MetricKeyType7.MetricKeyType.Histogram, number, effect_MetricState7.MetricState.Histogram>;
+  activeUploadsGauge: effect_Metric49.Metric.Gauge<number>;
+  uploadThroughputGauge: effect_Metric49.Metric.Gauge<number>;
+  uploadLatencySummary: effect_Metric49.Metric.Summary<number>;
+  chunkLatencySummary: effect_Metric49.Metric.Summary<number>;
 };
 /**
  * Validate that all required metrics exist
@@ -785,5 +1759,5 @@ declare const withChunkContext: (context: {
   totalSize?: number;
 }) => Effect.Effect<void, never, never>;
 //#endregion
-export { AzureMetrics, AzureObservabilityLayer, AzureTracingLayer, CircuitBreakerTracingState, FilesystemMetrics, FilesystemObservabilityLayer, FilesystemTracingLayer, FlowErrorCategory, FlowMetrics, FlowObservability, FlowObservabilityDisabled, FlowObservabilityLive, FlowObservabilityService, GCSMetrics, GCSObservabilityLayer, GCSTracingLayer, MetricsService, NoOpMetricsServiceLive, NodeSdkLive, Observability, ObservabilityDisabled, ObservabilityService, ObservabilityTestFixture, S3Metrics, S3ObservabilityLayer, S3TracingLayer, StorageErrorCategory, StorageMetrics, StorageObservability, StorageObservabilityDisabled, StorageObservabilityService, TracingService, UploadErrorCategory, UploadObservability, UploadObservabilityDisabled, UploadObservabilityLive, UploadObservabilityService, UploadObservabilityTest, UploadServerMetrics, WebSdkLive, WorkersSdkLive, annotateCircuitBreakerStateChange, azureActiveUploadsGauge, azureApiCallsTotal, azureFileSizeHistogram, azureMetrics, azurePartSizeHistogram, azurePartUploadDurationHistogram, azureUploadDurationHistogram, azureUploadErrorsTotal, azureUploadLatencySummary, azureUploadPartsTotal, azureUploadRequestsTotal, azureUploadSuccessTotal, azureUploadThroughputGauge, captureMetrics, classifyFlowError, classifyStorageError, classifyUploadError, createFlowMetrics, createStorageErrorClassifier, createStorageErrorTracker, createStorageMetrics, createStorageTracingLayer, createTestFixture, createTracingLayer, createUploadErrorClassifier, createUploadGauges, createUploadHistograms, createUploadMetrics, createUploadServerMetrics, createUploadSummaries, filesystemActiveUploadsGauge, filesystemApiCallsTotal, filesystemFileSizeHistogram, filesystemMetrics, filesystemPartSizeHistogram, filesystemPartUploadDurationHistogram, filesystemUploadDurationHistogram, filesystemUploadErrorsTotal, filesystemUploadLatencySummary, filesystemUploadPartsTotal, filesystemUploadRequestsTotal, filesystemUploadSuccessTotal, filesystemUploadThroughputGauge, flowMetrics, gcsActiveUploadsGauge, gcsApiCallsTotal, gcsFileSizeHistogram, gcsMetrics, gcsPartSizeHistogram, gcsPartUploadDurationHistogram, gcsUploadDurationHistogram, gcsUploadErrorsTotal, gcsUploadLatencySummary, gcsUploadPartsTotal, gcsUploadRequestsTotal, gcsUploadSuccessTotal, gcsUploadThroughputGauge, getFlowMetrics, getTestMetrics, getUploadMetrics, isObservabilityEnabled, logAzureContext, logAzureOperation, logAzureUploadCompletion, logAzureUploadProgress, logFilesystemContext, logFilesystemOperation, logFilesystemUploadCompletion, logFilesystemUploadProgress, logGCSContext, logGCSOperation, logGCSUploadCompletion, logGCSUploadProgress, logS3Context, logS3Operation, logS3UploadCompletion, logS3UploadProgress, logStorageOperation, logUploadCompletion, logUploadProgress, logWithContext, makeFlowObservabilityLayer, makeFlowObservabilityLive, makeObservabilityLayer, makeStorageObservabilityLayer, makeTestFlowObservability, makeTestFlowObservability$1 as makeTestFlowObservabilityUtil, makeTestStorageObservability, makeTestUploadObservability, makeUploadObservabilityLayer, makeUploadObservabilityLive, runWithTestFlowObservability, runWithTestObservability, s3ActiveUploadsGauge, s3ApiCallsTotal, s3FileSizeHistogram, s3Metrics, s3PartSizeHistogram, s3PartUploadDurationHistogram, s3UploadDurationHistogram, s3UploadErrorsTotal, s3UploadLatencySummary, s3UploadPartsTotal, s3UploadRequestsTotal, s3UploadSuccessTotal, s3UploadThroughputGauge, trackActiveFlow, trackActiveNode, trackAzureError, trackFileSize, trackFilesystemError, trackFlowError, trackGCSError, trackNodeError, trackPartSize, trackS3Error, trackStorageError, trackUploadError, uploadServerMetrics, validateMetricsExist, whenObservabilityEnabled, withActiveUploadTracking, withApiMetrics, withAzureApiMetrics, withAzureOperationMetrics, withAzureSpan, withAzureTimingMetrics, withAzureUploadMetrics, withChunkContext, withChunkDuration, withCircuitBreakerContext, withCircuitBreakerSpan, withExecutionContext, withFilesystemApiMetrics, withFilesystemOperationMetrics, withFilesystemSpan, withFilesystemTimingMetrics, withFilesystemUploadMetrics, withFlowContext, withFlowDuration, withFlowSpan, withGCSApiMetrics, withGCSOperationMetrics, withGCSSpan, withGCSTimingMetrics, withGCSUploadMetrics, withMetricTracking, withNodeContext, withNodeDuration, withS3ApiMetrics, withS3OperationMetrics, withS3Span, withS3TimingMetrics, withS3UploadMetrics, withStorageOperationMetrics, withStorageSpan, withThroughputTracking, withTimingMetrics, withUploadContext, withUploadDuration, withUploadMetrics, withUploadSpan };
+export { AzureMetrics, AzureObservabilityLayer, AzureTracingLayer, BatchLogRecordProcessor, CircuitBreakerTracingState, Environment, FilesystemMetrics, FilesystemObservabilityLayer, FilesystemTracingLayer, FlowErrorCategory, FlowMetrics, FlowObservability, FlowObservabilityDisabled, FlowObservabilityLive, FlowObservabilityService, FullObservabilityConfig, GCSMetrics, GCSObservabilityLayer, GCSTracingLayer, LoggerProvider, LogsLayerConfig, LogsSdkConfig, MeterProvider, MetricsSdkConfig, MetricsService, NoOpMetricsServiceLive, NodeSdkLive, OTLPLogExporter, OTLPMetricExporter, Observability, ObservabilityDisabled, ObservabilityService, ObservabilityTestFixture, OperationDomain, OtelLogger, OtelLoggerService, OtelMeter, OtelMeterService, OtlpAutoSdkLive, OtlpExporterConfig, OtlpFullObservabilityNodeSdkLive, OtlpFullObservabilityWebSdkLive, OtlpFullObservabilityWorkersSdkLive, OtlpLogsNodeSdkLive, OtlpLogsWebSdkLive, OtlpLogsWorkersSdkLive, OtlpMetricsNodeSdkLive, OtlpMetricsWebSdkLive, OtlpMetricsWorkersSdkLive, OtlpNodeSdkLive, OtlpSdkConfig, OtlpWebSdkLive, OtlpWorkersSdkLive, PeriodicExportingMetricReader, S3Metrics, S3ObservabilityLayer, S3TracingLayer, SeverityNumber, StorageErrorCategory, StorageMetrics, StorageObservability, StorageObservabilityDisabled, StorageObservabilityService, TraceContext, TracingService, UploadErrorCategory, UploadObservability, UploadObservabilityDisabled, UploadObservabilityLive, UploadObservabilityService, UploadObservabilityTest, UploadServerMetrics, WebSdkLive, WorkersSdkLive, annotateCircuitBreakerStateChange, azureActiveUploadsGauge, azureApiCallsTotal, azureFileSizeHistogram, azureMetrics, azurePartSizeHistogram, azurePartUploadDurationHistogram, azureUploadDurationHistogram, azureUploadErrorsTotal, azureUploadLatencySummary, azureUploadPartsTotal, azureUploadRequestsTotal, azureUploadSuccessTotal, azureUploadThroughputGauge, captureMetrics, captureTraceContext, captureTraceContextEffect, classifyFlowError, classifyStorageError, classifyUploadError, createExternalSpan, createFlowMetrics, createGauge, createOtlpAutoSdkLayer, createOtlpEffectLogger, createOtlpFullObservabilityNodeSdkLayer, createOtlpFullObservabilityWebSdkLayer, createOtlpFullObservabilityWorkersSdkLayer, createOtlpLogExporter, createOtlpLoggerProvider, createOtlpLogsNodeSdkLayer, createOtlpLogsWebSdkLayer, createOtlpLogsWorkersSdkLayer, createOtlpMeterProvider, createOtlpMetricExporter, createOtlpMetricsNodeSdkLayer, createOtlpMetricsWebSdkLayer, createOtlpMetricsWorkersSdkLayer, createOtlpNodeSdkLayer, createOtlpTraceExporter, createOtlpWebSdkLayer, createOtlpWorkersSdkLayer, createStorageErrorClassifier, createStorageErrorTracker, createStorageMetrics, createStorageTracingLayer, createTestFixture, createTracingLayer, createUploadErrorClassifier, createUploadGauges, createUploadHistograms, createUploadMetrics, createUploadServerMetrics, createUploadSummaries, detectEnvironment, emitLog, filesystemActiveUploadsGauge, filesystemApiCallsTotal, filesystemFileSizeHistogram, filesystemMetrics, filesystemPartSizeHistogram, filesystemPartUploadDurationHistogram, filesystemUploadDurationHistogram, filesystemUploadErrorsTotal, filesystemUploadLatencySummary, filesystemUploadPartsTotal, filesystemUploadRequestsTotal, filesystemUploadSuccessTotal, filesystemUploadThroughputGauge, flowMetrics, gcsActiveUploadsGauge, gcsApiCallsTotal, gcsFileSizeHistogram, gcsMetrics, gcsPartSizeHistogram, gcsPartUploadDurationHistogram, gcsUploadDurationHistogram, gcsUploadErrorsTotal, gcsUploadLatencySummary, gcsUploadPartsTotal, gcsUploadRequestsTotal, gcsUploadSuccessTotal, gcsUploadThroughputGauge, getFlowMetrics, getLogsExportInterval, getMetricsExportInterval, getOtlpEndpoint, getServiceName, getTestMetrics, getTraceContext, getUploadMetrics, hasActiveTraceContext, isObservabilityEnabled, isOtlpExportEnabled, logAzureContext, logAzureOperation, logAzureUploadCompletion, logAzureUploadProgress, logDebug, logError, logFatal, logFilesystemContext, logFilesystemOperation, logFilesystemUploadCompletion, logFilesystemUploadProgress, logGCSContext, logGCSOperation, logGCSUploadCompletion, logGCSUploadProgress, logInfo, logS3Context, logS3Operation, logS3UploadCompletion, logS3UploadProgress, logStorageOperation, logUploadCompletion, logUploadProgress, logWarn, logWithContext, makeFlowObservabilityLayer, makeFlowObservabilityLive, makeObservabilityLayer, makeStorageObservabilityLayer, makeTestFlowObservability, makeTestFlowObservability$1 as makeTestFlowObservabilityUtil, makeTestStorageObservability, makeTestUploadObservability, makeUploadObservabilityLayer, makeUploadObservabilityLive, mapLogLevelToSeverity, parseOtlpHeaders, parseResourceAttributes, recordCounter, recordHistogram, runWithTestFlowObservability, runWithTestObservability, s3ActiveUploadsGauge, s3ApiCallsTotal, s3FileSizeHistogram, s3Metrics, s3PartSizeHistogram, s3PartUploadDurationHistogram, s3UploadDurationHistogram, s3UploadErrorsTotal, s3UploadLatencySummary, s3UploadPartsTotal, s3UploadRequestsTotal, s3UploadSuccessTotal, s3UploadThroughputGauge, severityToText, trackActiveFlow, trackActiveNode, trackAzureError, trackFileSize, trackFilesystemError, trackFlowError, trackGCSError, trackNodeError, trackPartSize, trackS3Error, trackStorageError, trackUploadError, uploadServerMetrics, validateMetricsExist, whenObservabilityEnabled, withActiveUploadTracking, withApiMetrics, withAzureApiMetrics, withAzureOperationMetrics, withAzureSpan, withAzureTimingMetrics, withAzureUploadMetrics, withChunkContext, withChunkDuration, withCircuitBreakerContext, withCircuitBreakerSpan, withExecutionContext, withFilesystemApiMetrics, withFilesystemOperationMetrics, withFilesystemSpan, withFilesystemTimingMetrics, withFilesystemUploadMetrics, withFlowContext, withFlowDuration, withFlowSpan, withGCSApiMetrics, withGCSOperationMetrics, withGCSSpan, withGCSTimingMetrics, withGCSUploadMetrics, withMetricTracking, withNodeContext, withNodeDuration, withOperationContext, withOperationSpan, withParentContext, withS3ApiMetrics, withS3OperationMetrics, withS3Span, withS3TimingMetrics, withS3UploadMetrics, withStorageOperationMetrics, withStorageSpan, withThroughputTracking, withTimingMetrics, withUploadContext, withUploadDuration, withUploadMetrics, withUploadSpan };
 //# sourceMappingURL=index.d.cts.map