autotel-aws 0.2.0

package/dist/lambda.d.cts

@@ -0,0 +1,231 @@
+import { TraceContext } from 'autotel';
+import { L as LambdaHandler } from './types-kTFVdSqO.cjs';
+export { a as LambdaTrigger } from './types-kTFVdSqO.cjs';
+import { L as LambdaEvent } from './types-3_ak5jhy.cjs';
+import { L as LambdaInstrumentationConfig } from './config-C7zV8Zm6.cjs';
+import { MiddlewareObj, Request } from '@middy/core';
+import { Context } from 'aws-lambda';
+import { Span, Context as Context$1, SpanContext } from '@opentelemetry/api';
+
+/**
+ * Lambda handler wrappers
+ *
+ * Provides instrumentation wrappers for AWS Lambda handlers with automatic
+ * trace context extraction from various event sources (API Gateway, SQS, SNS, etc.).
+ *
+ * @example Simple wrapper
+ * ```typescript
+ * import { wrapHandler } from 'autotel-aws/lambda';
+ *
+ * export const handler = wrapHandler(async (event, context) => {
+ *   return { statusCode: 200 };
+ * });
+ * ```
+ *
+ * @example With context access
+ * ```typescript
+ * import { traceLambda } from 'autotel-aws/lambda';
+ *
+ * export const handler = traceLambda(ctx => async (event, context) => {
+ *   ctx.setAttribute('user.id', event.userId);
+ *   return { statusCode: 200 };
+ * });
+ * ```
+ */
+
+/**
+ * Wrap Lambda handler with OpenTelemetry instrumentation
+ *
+ * Automatically extracts trace context from incoming events and creates
+ * a root span for the Lambda invocation with proper semantic attributes.
+ *
+ * @param handler - The Lambda handler function to wrap
+ * @param config - Optional instrumentation configuration
+ * @returns Wrapped handler with automatic tracing
+ *
+ * @example Basic usage
+ * ```typescript
+ * export const handler = wrapHandler(async (event, context) => {
+ *   // Your handler code - automatically traced
+ *   return { statusCode: 200 };
+ * });
+ * ```
+ *
+ * @example With configuration
+ * ```typescript
+ * export const handler = wrapHandler(
+ *   async (event, context) => {
+ *     return { statusCode: 200, body: JSON.stringify({ result: 'ok' }) };
+ *   },
+ *   { captureResponse: true, extractTraceContext: true }
+ * );
+ * ```
+ *
+ * @remarks
+ * Semantic attributes set automatically:
+ * - `faas.name` - Function name
+ * - `faas.version` - Function version
+ * - `faas.invocation_id` - AWS request ID
+ * - `faas.coldstart` - Whether this is a cold start
+ * - `faas.trigger` - Trigger type (http, pubsub, datasource, timer, other)
+ * - `cloud.provider` - 'aws'
+ * - `cloud.region` - AWS region
+ * - `cloud.account.id` - AWS account ID (extracted from ARN)
+ */
+declare function wrapHandler<TEvent = LambdaEvent, TResult = unknown>(handler: LambdaHandler<TEvent, TResult>, config?: LambdaInstrumentationConfig): LambdaHandler<TEvent, TResult>;
+/**
+ * Functional API for Lambda with trace context access
+ *
+ * Similar to `wrapHandler`, but provides access to the trace context
+ * for setting custom attributes during handler execution.
+ *
+ * @param factory - Factory function that receives trace context and returns a handler
+ * @param config - Optional instrumentation configuration
+ * @returns Wrapped handler with automatic tracing
+ *
+ * @example
+ * ```typescript
+ * export const handler = traceLambda(ctx => async (event, context) => {
+ *   // Access trace context for custom attributes
+ *   ctx.setAttribute('user.id', event.userId);
+ *   ctx.setAttribute('order.id', event.orderId);
+ *
+ *   // Use X-Ray annotations for indexed attributes
+ *   setXRayAnnotation('user.tier', event.userTier);
+ *
+ *   const result = await processOrder(event);
+ *   ctx.setAttribute('order.status', result.status);
+ *
+ *   return { statusCode: 200, body: JSON.stringify(result) };
+ * });
+ * ```
+ *
+ * @remarks
+ * The trace context (`ctx`) provides:
+ * - `setAttribute(key, value)` - Set a single attribute
+ * - `setAttributes(attrs)` - Set multiple attributes
+ * - `setStatus(status)` - Set span status
+ * - `recordException(error)` - Record an exception
+ * - `traceId`, `spanId` - Trace identifiers
+ */
+declare function traceLambda<TEvent = LambdaEvent, TResult = unknown>(factory: (ctx: TraceContext) => LambdaHandler<TEvent, TResult>, config?: LambdaInstrumentationConfig): LambdaHandler<TEvent, TResult>;
+
+/**
+ * Middy-compatible Lambda middleware for OpenTelemetry instrumentation
+ *
+ * Provides full span lifecycle management for Lambda handlers using Middy.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import middy from '@middy/core';
+ * import { tracingMiddleware } from 'autotel-aws/lambda';
+ *
+ * const baseHandler = async (event, context) => {
+ *   return { statusCode: 200 };
+ * };
+ *
+ * export const handler = middy(baseHandler)
+ *   .use(tracingMiddleware());
+ * ```
+ *
+ * @example With configuration
+ * ```typescript
+ * export const handler = middy(baseHandler)
+ *   .use(tracingMiddleware({
+ *     captureResponse: true,
+ *     extractTraceContext: true
+ *   }));
+ * ```
+ *
+ * @example Combined with other middleware
+ * ```typescript
+ * export const handler = middy(baseHandler)
+ *   .use(tracingMiddleware())
+ *   .use(jsonBodyParser())
+ *   .use(httpErrorHandler());
+ * ```
+ */
+
+/**
+ * Middy middleware for Lambda instrumentation with full span lifecycle
+ *
+ * Creates a span that wraps the entire handler execution, including:
+ * - Trace context extraction from incoming events
+ * - Cold start detection
+ * - Semantic attributes for Lambda (faas.*, cloud.*)
+ * - Error recording and status
+ * - Response capture (optional)
+ *
+ * @param config - Optional instrumentation configuration
+ * @returns Middy middleware object
+ *
+ * @remarks
+ * This middleware uses Middy's before/after/onError hooks to manage
+ * the span lifecycle. The span is created in `before`, ended in `after`
+ * or `onError`.
+ *
+ * Semantic attributes set automatically:
+ * - `faas.name` - Function name
+ * - `faas.version` - Function version
+ * - `faas.invocation_id` - AWS request ID
+ * - `faas.coldstart` - Whether this is a cold start
+ * - `faas.trigger` - Trigger type (http, pubsub, datasource, timer, other)
+ * - `cloud.provider` - 'aws'
+ * - `cloud.region` - AWS region
+ * - `cloud.account.id` - AWS account ID (extracted from ARN)
+ */
+declare function tracingMiddleware(config?: LambdaInstrumentationConfig): MiddlewareObj<LambdaEvent, unknown, Error, Context>;
+/**
+ * @deprecated Use tracingMiddleware instead. LambdaMiddleware is an alias for backwards compatibility.
+ */
+declare const LambdaMiddleware: typeof tracingMiddleware;
+/**
+ * Get the current span from a Middy request object
+ *
+ * Useful for setting custom attributes within your handler when using
+ * the tracing middleware.
+ *
+ * @param request - Middy request object
+ * @returns The active span, or undefined if not available
+ *
+ * @example
+ * ```typescript
+ * const baseHandler = async (event, context) => {
+ *   const span = getSpanFromRequest(request);
+ *   if (span) {
+ *     span.setAttribute('user.id', event.userId);
+ *   }
+ *   return { statusCode: 200 };
+ * };
+ * ```
+ */
+declare function getSpanFromRequest(request: Request<any, any, any, any>): Span | undefined;
+/**
+ * Get the OpenTelemetry context from a Middy request object
+ *
+ * @param request - Middy request object
+ * @returns The active context, or undefined if not available
+ */
+declare function getContextFromRequest(request: Request<any, any, any, any>): Context$1 | undefined;
+
+/**
+ * Extract trace context from Lambda events
+ */
+
+/**
+ * Extract trace context from Lambda event
+ *
+ * Supports:
+ * - API Gateway (W3C Trace Context headers)
+ * - SQS (message attributes)
+ * - SNS (message attributes)
+ * - X-Ray header (Lambda integration)
+ * - Step Functions (payload context)
+ */
+declare function extractTraceContext(event: LambdaEvent): SpanContext | undefined;
+/**
+ * Detect Lambda trigger type from event
+ */
+declare function detectTriggerType(event: LambdaEvent): 'http' | 'pubsub' | 'datasource' | 'timer' | 'other';
+
+export { LambdaHandler, LambdaMiddleware, detectTriggerType, extractTraceContext, getContextFromRequest, getSpanFromRequest, traceLambda, tracingMiddleware, wrapHandler };

package/dist/lambda.d.ts

@@ -0,0 +1,231 @@
+import { TraceContext } from 'autotel';
+import { L as LambdaHandler } from './types-UiBv_I_M.js';
+export { a as LambdaTrigger } from './types-UiBv_I_M.js';
+import { L as LambdaEvent } from './types-3_ak5jhy.js';
+import { L as LambdaInstrumentationConfig } from './config-DxjTT8jd.js';
+import { MiddlewareObj, Request } from '@middy/core';
+import { Context } from 'aws-lambda';
+import { Span, Context as Context$1, SpanContext } from '@opentelemetry/api';
+
+/**
+ * Lambda handler wrappers
+ *
+ * Provides instrumentation wrappers for AWS Lambda handlers with automatic
+ * trace context extraction from various event sources (API Gateway, SQS, SNS, etc.).
+ *
+ * @example Simple wrapper
+ * ```typescript
+ * import { wrapHandler } from 'autotel-aws/lambda';
+ *
+ * export const handler = wrapHandler(async (event, context) => {
+ *   return { statusCode: 200 };
+ * });
+ * ```
+ *
+ * @example With context access
+ * ```typescript
+ * import { traceLambda } from 'autotel-aws/lambda';
+ *
+ * export const handler = traceLambda(ctx => async (event, context) => {
+ *   ctx.setAttribute('user.id', event.userId);
+ *   return { statusCode: 200 };
+ * });
+ * ```
+ */
+
+/**
+ * Wrap Lambda handler with OpenTelemetry instrumentation
+ *
+ * Automatically extracts trace context from incoming events and creates
+ * a root span for the Lambda invocation with proper semantic attributes.
+ *
+ * @param handler - The Lambda handler function to wrap
+ * @param config - Optional instrumentation configuration
+ * @returns Wrapped handler with automatic tracing
+ *
+ * @example Basic usage
+ * ```typescript
+ * export const handler = wrapHandler(async (event, context) => {
+ *   // Your handler code - automatically traced
+ *   return { statusCode: 200 };
+ * });
+ * ```
+ *
+ * @example With configuration
+ * ```typescript
+ * export const handler = wrapHandler(
+ *   async (event, context) => {
+ *     return { statusCode: 200, body: JSON.stringify({ result: 'ok' }) };
+ *   },
+ *   { captureResponse: true, extractTraceContext: true }
+ * );
+ * ```
+ *
+ * @remarks
+ * Semantic attributes set automatically:
+ * - `faas.name` - Function name
+ * - `faas.version` - Function version
+ * - `faas.invocation_id` - AWS request ID
+ * - `faas.coldstart` - Whether this is a cold start
+ * - `faas.trigger` - Trigger type (http, pubsub, datasource, timer, other)
+ * - `cloud.provider` - 'aws'
+ * - `cloud.region` - AWS region
+ * - `cloud.account.id` - AWS account ID (extracted from ARN)
+ */
+declare function wrapHandler<TEvent = LambdaEvent, TResult = unknown>(handler: LambdaHandler<TEvent, TResult>, config?: LambdaInstrumentationConfig): LambdaHandler<TEvent, TResult>;
+/**
+ * Functional API for Lambda with trace context access
+ *
+ * Similar to `wrapHandler`, but provides access to the trace context
+ * for setting custom attributes during handler execution.
+ *
+ * @param factory - Factory function that receives trace context and returns a handler
+ * @param config - Optional instrumentation configuration
+ * @returns Wrapped handler with automatic tracing
+ *
+ * @example
+ * ```typescript
+ * export const handler = traceLambda(ctx => async (event, context) => {
+ *   // Access trace context for custom attributes
+ *   ctx.setAttribute('user.id', event.userId);
+ *   ctx.setAttribute('order.id', event.orderId);
+ *
+ *   // Use X-Ray annotations for indexed attributes
+ *   setXRayAnnotation('user.tier', event.userTier);
+ *
+ *   const result = await processOrder(event);
+ *   ctx.setAttribute('order.status', result.status);
+ *
+ *   return { statusCode: 200, body: JSON.stringify(result) };
+ * });
+ * ```
+ *
+ * @remarks
+ * The trace context (`ctx`) provides:
+ * - `setAttribute(key, value)` - Set a single attribute
+ * - `setAttributes(attrs)` - Set multiple attributes
+ * - `setStatus(status)` - Set span status
+ * - `recordException(error)` - Record an exception
+ * - `traceId`, `spanId` - Trace identifiers
+ */
+declare function traceLambda<TEvent = LambdaEvent, TResult = unknown>(factory: (ctx: TraceContext) => LambdaHandler<TEvent, TResult>, config?: LambdaInstrumentationConfig): LambdaHandler<TEvent, TResult>;
+
+/**
+ * Middy-compatible Lambda middleware for OpenTelemetry instrumentation
+ *
+ * Provides full span lifecycle management for Lambda handlers using Middy.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import middy from '@middy/core';
+ * import { tracingMiddleware } from 'autotel-aws/lambda';
+ *
+ * const baseHandler = async (event, context) => {
+ *   return { statusCode: 200 };
+ * };
+ *
+ * export const handler = middy(baseHandler)
+ *   .use(tracingMiddleware());
+ * ```
+ *
+ * @example With configuration
+ * ```typescript
+ * export const handler = middy(baseHandler)
+ *   .use(tracingMiddleware({
+ *     captureResponse: true,
+ *     extractTraceContext: true
+ *   }));
+ * ```
+ *
+ * @example Combined with other middleware
+ * ```typescript
+ * export const handler = middy(baseHandler)
+ *   .use(tracingMiddleware())
+ *   .use(jsonBodyParser())
+ *   .use(httpErrorHandler());
+ * ```
+ */
+
+/**
+ * Middy middleware for Lambda instrumentation with full span lifecycle
+ *
+ * Creates a span that wraps the entire handler execution, including:
+ * - Trace context extraction from incoming events
+ * - Cold start detection
+ * - Semantic attributes for Lambda (faas.*, cloud.*)
+ * - Error recording and status
+ * - Response capture (optional)
+ *
+ * @param config - Optional instrumentation configuration
+ * @returns Middy middleware object
+ *
+ * @remarks
+ * This middleware uses Middy's before/after/onError hooks to manage
+ * the span lifecycle. The span is created in `before`, ended in `after`
+ * or `onError`.
+ *
+ * Semantic attributes set automatically:
+ * - `faas.name` - Function name
+ * - `faas.version` - Function version
+ * - `faas.invocation_id` - AWS request ID
+ * - `faas.coldstart` - Whether this is a cold start
+ * - `faas.trigger` - Trigger type (http, pubsub, datasource, timer, other)
+ * - `cloud.provider` - 'aws'
+ * - `cloud.region` - AWS region
+ * - `cloud.account.id` - AWS account ID (extracted from ARN)
+ */
+declare function tracingMiddleware(config?: LambdaInstrumentationConfig): MiddlewareObj<LambdaEvent, unknown, Error, Context>;
+/**
+ * @deprecated Use tracingMiddleware instead. LambdaMiddleware is an alias for backwards compatibility.
+ */
+declare const LambdaMiddleware: typeof tracingMiddleware;
+/**
+ * Get the current span from a Middy request object
+ *
+ * Useful for setting custom attributes within your handler when using
+ * the tracing middleware.
+ *
+ * @param request - Middy request object
+ * @returns The active span, or undefined if not available
+ *
+ * @example
+ * ```typescript
+ * const baseHandler = async (event, context) => {
+ *   const span = getSpanFromRequest(request);
+ *   if (span) {
+ *     span.setAttribute('user.id', event.userId);
+ *   }
+ *   return { statusCode: 200 };
+ * };
+ * ```
+ */
+declare function getSpanFromRequest(request: Request<any, any, any, any>): Span | undefined;
+/**
+ * Get the OpenTelemetry context from a Middy request object
+ *
+ * @param request - Middy request object
+ * @returns The active context, or undefined if not available
+ */
+declare function getContextFromRequest(request: Request<any, any, any, any>): Context$1 | undefined;
+
+/**
+ * Extract trace context from Lambda events
+ */
+
+/**
+ * Extract trace context from Lambda event
+ *
+ * Supports:
+ * - API Gateway (W3C Trace Context headers)
+ * - SQS (message attributes)
+ * - SNS (message attributes)
+ * - X-Ray header (Lambda integration)
+ * - Step Functions (payload context)
+ */
+declare function extractTraceContext(event: LambdaEvent): SpanContext | undefined;
+/**
+ * Detect Lambda trigger type from event
+ */
+declare function detectTriggerType(event: LambdaEvent): 'http' | 'pubsub' | 'datasource' | 'timer' | 'other';
+
+export { LambdaHandler, LambdaMiddleware, detectTriggerType, extractTraceContext, getContextFromRequest, getSpanFromRequest, traceLambda, tracingMiddleware, wrapHandler };

package/dist/lambda.js

@@ -0,0 +1,5 @@
+export { LambdaMiddleware, detectTriggerType, extractTraceContext, getContextFromRequest, getSpanFromRequest, traceLambda, tracingMiddleware, wrapHandler } from './chunk-V4IQWFYN.js';
+import './chunk-I4CKQ4RD.js';
+import './chunk-DGUM43GV.js';
+//# sourceMappingURL=lambda.js.map
+//# sourceMappingURL=lambda.js.map

package/dist/lambda.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"lambda.js"}

package/dist/s3.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+var chunkDHHLKZHI_cjs = require('./chunk-DHHLKZHI.cjs');
+require('./chunk-Q3DMMQ7K.cjs');
+require('./chunk-JEQ2X3Z6.cjs');
+
+
+
+Object.defineProperty(exports, "traceS3", {
+  enumerable: true,
+  get: function () { return chunkDHHLKZHI_cjs.traceS3; }
+});
+//# sourceMappingURL=s3.cjs.map
+//# sourceMappingURL=s3.cjs.map

package/dist/s3.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"s3.cjs"}

package/dist/s3.d.cts

@@ -0,0 +1,77 @@
+import { TraceContext } from 'autotel';
+
+/**
+ * S3-specific instrumentation
+ *
+ * Provides semantic helpers for tracing S3 operations with proper OpenTelemetry
+ * semantic conventions. Automatically sets `aws.s3.*` attributes.
+ *
+ * @example Basic usage with factory pattern
+ * ```typescript
+ * import { traceS3 } from 'autotel-aws/s3';
+ * import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
+ *
+ * const s3 = new S3Client({});
+ *
+ * export const getFile = traceS3({
+ *   operation: 'GetObject',
+ *   bucket: 'my-bucket'
+ * })(ctx => async (key: string) => {
+ *   ctx.setAttribute('aws.s3.key', key);
+ *   return await s3.send(new GetObjectCommand({ Bucket: 'my-bucket', Key: key }));
+ * });
+ *
+ * // Usage: await getFile('path/to/file.txt');
+ * ```
+ *
+ * @example Dynamic bucket
+ * ```typescript
+ * export const getObject = traceS3({
+ *   operation: 'GetObject',
+ * })(ctx => async (bucket: string, key: string) => {
+ *   ctx.setAttribute('aws.s3.bucket', bucket);
+ *   ctx.setAttribute('aws.s3.key', key);
+ *   return await s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+ * });
+ *
+ * // Usage: await getObject('my-bucket', 'file.txt');
+ * ```
+ */
+
+/**
+ * S3 operation configuration
+ */
+interface TraceS3Config {
+    /**
+     * S3 operation name (e.g., 'GetObject', 'PutObject', 'DeleteObject')
+     * Used to generate the span name: `s3.{operation}`
+     */
+    operation: string;
+    /**
+     * Default bucket name for static configurations.
+     * Can be overridden by setting `aws.s3.bucket` attribute in the handler.
+     */
+    bucket?: string;
+}
+/**
+ * Trace S3 operations with semantic attributes
+ *
+ * Creates a traced function that automatically sets S3 semantic attributes
+ * following OpenTelemetry conventions.
+ *
+ * @param config - S3 operation configuration
+ * @returns A higher-order function that wraps your S3 operation with tracing
+ *
+ * @remarks
+ * Semantic attributes set automatically:
+ * - `aws.s3.bucket` - S3 bucket name (if provided in config)
+ *
+ * Additional attributes you should set in your handler:
+ * - `aws.s3.key` - Object key
+ * - `aws.s3.copy_source` - Source for copy operations
+ *
+ * @see https://opentelemetry.io/docs/specs/semconv/object-stores/s3/
+ */
+declare function traceS3(config: TraceS3Config): <TArgs extends unknown[], TReturn>(fn: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>) => (...args: TArgs) => Promise<TReturn>;
+
+export { type TraceS3Config, traceS3 };

package/dist/s3.d.ts

@@ -0,0 +1,77 @@
+import { TraceContext } from 'autotel';
+
+/**
+ * S3-specific instrumentation
+ *
+ * Provides semantic helpers for tracing S3 operations with proper OpenTelemetry
+ * semantic conventions. Automatically sets `aws.s3.*` attributes.
+ *
+ * @example Basic usage with factory pattern
+ * ```typescript
+ * import { traceS3 } from 'autotel-aws/s3';
+ * import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
+ *
+ * const s3 = new S3Client({});
+ *
+ * export const getFile = traceS3({
+ *   operation: 'GetObject',
+ *   bucket: 'my-bucket'
+ * })(ctx => async (key: string) => {
+ *   ctx.setAttribute('aws.s3.key', key);
+ *   return await s3.send(new GetObjectCommand({ Bucket: 'my-bucket', Key: key }));
+ * });
+ *
+ * // Usage: await getFile('path/to/file.txt');
+ * ```
+ *
+ * @example Dynamic bucket
+ * ```typescript
+ * export const getObject = traceS3({
+ *   operation: 'GetObject',
+ * })(ctx => async (bucket: string, key: string) => {
+ *   ctx.setAttribute('aws.s3.bucket', bucket);
+ *   ctx.setAttribute('aws.s3.key', key);
+ *   return await s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+ * });
+ *
+ * // Usage: await getObject('my-bucket', 'file.txt');
+ * ```
+ */
+
+/**
+ * S3 operation configuration
+ */
+interface TraceS3Config {
+    /**
+     * S3 operation name (e.g., 'GetObject', 'PutObject', 'DeleteObject')
+     * Used to generate the span name: `s3.{operation}`
+     */
+    operation: string;
+    /**
+     * Default bucket name for static configurations.
+     * Can be overridden by setting `aws.s3.bucket` attribute in the handler.
+     */
+    bucket?: string;
+}
+/**
+ * Trace S3 operations with semantic attributes
+ *
+ * Creates a traced function that automatically sets S3 semantic attributes
+ * following OpenTelemetry conventions.
+ *
+ * @param config - S3 operation configuration
+ * @returns A higher-order function that wraps your S3 operation with tracing
+ *
+ * @remarks
+ * Semantic attributes set automatically:
+ * - `aws.s3.bucket` - S3 bucket name (if provided in config)
+ *
+ * Additional attributes you should set in your handler:
+ * - `aws.s3.key` - Object key
+ * - `aws.s3.copy_source` - Source for copy operations
+ *
+ * @see https://opentelemetry.io/docs/specs/semconv/object-stores/s3/
+ */
+declare function traceS3(config: TraceS3Config): <TArgs extends unknown[], TReturn>(fn: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>) => (...args: TArgs) => Promise<TReturn>;
+
+export { type TraceS3Config, traceS3 };

package/dist/s3.js

@@ -0,0 +1,5 @@
+export { traceS3 } from './chunk-ZPDRKCAR.js';
+import './chunk-I4CKQ4RD.js';
+import './chunk-DGUM43GV.js';
+//# sourceMappingURL=s3.js.map
+//# sourceMappingURL=s3.js.map

package/dist/s3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"s3.js"}

package/dist/sdk.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var chunk4TGVGEUN_cjs = require('./chunk-4TGVGEUN.cjs');
+require('./chunk-UZEJV2YD.cjs');
+require('./chunk-Q3DMMQ7K.cjs');
+require('./chunk-JEQ2X3Z6.cjs');
+
+
+
+Object.defineProperty(exports, "autoInstrumentAWS", {
+  enumerable: true,
+  get: function () { return chunk4TGVGEUN_cjs.autoInstrumentAWS; }
+});
+Object.defineProperty(exports, "createTracedClient", {
+  enumerable: true,
+  get: function () { return chunk4TGVGEUN_cjs.createTracedClient; }
+});
+Object.defineProperty(exports, "disableAutoInstrumentAWS", {
+  enumerable: true,
+  get: function () { return chunk4TGVGEUN_cjs.disableAutoInstrumentAWS; }
+});
+Object.defineProperty(exports, "instrumentSDK", {
+  enumerable: true,
+  get: function () { return chunk4TGVGEUN_cjs.instrumentSDK; }
+});
+Object.defineProperty(exports, "isAutoInstrumentEnabled", {
+  enumerable: true,
+  get: function () { return chunk4TGVGEUN_cjs.isAutoInstrumentEnabled; }
+});
+//# sourceMappingURL=sdk.cjs.map
+//# sourceMappingURL=sdk.cjs.map

package/dist/sdk.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"sdk.cjs"}