@geekmidas/telescope 10.0.0-alpha.99 → 10.0.0

package/dist/core-B4Jpia5H.d.cts

@@ -0,0 +1,78 @@
+import { SpanProcessorOptions, SpanProcessorStrategy } from "./types-BRzW1NM8.cjs";
+import { ReadableSpan, Span, SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
+
+//#region src/instrumentation/core.d.ts
+
+/**
+ * Create a span processor based on the strategy
+ */
+declare function createSpanProcessor(exporter: SpanExporter, options: SpanProcessorOptions): SpanProcessor;
+/**
+ * Get the recommended span processor strategy for an environment
+ */
+declare function getRecommendedStrategy(environment: 'server' | 'lambda' | 'edge' | 'custom'): SpanProcessorStrategy;
+/**
+ * Set the global span processor for flush operations
+ */
+declare function setGlobalSpanProcessor(processor: SpanProcessor): void;
+/**
+ * Set the global log processor for flush operations
+ */
+declare function setGlobalLogProcessor(processor: unknown): void;
+/**
+ * Check if telemetry is initialized
+ */
+declare function isTelemetryInitialized(): boolean;
+/**
+ * Flush all pending telemetry data.
+ * This is critical for serverless environments where the process may freeze.
+ *
+ * @example
+ * ```typescript
+ * // In a Lambda handler
+ * export const handler = async (event, context) => {
+ *   try {
+ *     const result = await processRequest(event);
+ *     return result;
+ *   } finally {
+ *     // Flush before Lambda freezes
+ *     await flushTelemetry();
+ *   }
+ * };
+ * ```
+ */
+declare function flushTelemetry(timeoutMs?: number): Promise<void>;
+/**
+ * Shutdown all telemetry processors
+ */
+declare function shutdownTelemetry(): Promise<void>;
+/**
+ * Enable debug logging for telemetry
+ */
+declare function enableTelemetryDebug(): void;
+/**
+ * Wraps a handler function to ensure telemetry is flushed before returning.
+ * Useful for Lambda handlers.
+ *
+ * @example
+ * ```typescript
+ * export const handler = withTelemetryFlush(async (event, context) => {
+ *   // Your Lambda logic here
+ *   return { statusCode: 200, body: 'OK' };
+ * });
+ * ```
+ */
+declare function withTelemetryFlush<TEvent, TResult>(handler: (event: TEvent, context: unknown) => Promise<TResult>): (event: TEvent, context: unknown) => Promise<TResult>;
+/**
+ * Noop span processor for testing or when telemetry is disabled
+ */
+declare class NoopSpanProcessor implements SpanProcessor {
+  forceFlush(): Promise<void>;
+  onStart(_span: Span): void;
+  onEnd(_span: ReadableSpan): void;
+  shutdown(): Promise<void>;
+}
+//# sourceMappingURL=core.d.ts.map
+//#endregion
+export { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush };
+//# sourceMappingURL=core-B4Jpia5H.d.cts.map

package/dist/core-B4Jpia5H.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-B4Jpia5H.d.cts","names":[],"sources":["../src/instrumentation/core.ts"],"sourcesContent":[],"mappings":";;;;;;;AAgCA;AAAmC,iBAAnB,mBAAA,CAAmB,QAAA,EACxB,YADwB,EAAA,OAAA,EAEzB,oBAFyB,CAAA,EAGhC,aAHgC;;;;AAGnB,iBAkBA,sBAAA,CAlBA,WAAA,EAAA,QAAA,GAAA,QAAA,GAAA,MAAA,GAAA,QAAA,CAAA,EAoBb,qBApBa;AAkBhB;AAiBA;AAQA;AAOgB,iBAfA,sBAAA,CAesB,SAAA,EAfY,aAeZ,CAAA,EAAA,IAAA;AAsBtC;AA+CA;AA0BA;AAgBgB,iBAtHA,qBAAA,CAsHkB,SAAA,EAAA,OAAA,CAAA,EAAA,IAAA;;;;AACa,iBAhH/B,sBAAA,CAAA,CAgH+B,EAAA,OAAA;;;;AACA;AAa/C;;;;;;;AAAuD;;;;;;;iBAxGjC,cAAA,sBAAmC;;;;iBA+CnC,iBAAA,CAAA,GAAqB;;;;iBA0B3B,oBAAA,CAAA;;;;;;;;;;;;;iBAgBA,qDACE,6BAA6B,QAAQ,mBAC5C,6BAA6B,QAAQ;;;;cAanC,iBAAA,YAA6B;gBAC3B;iBAIC;eAIF;cAID"}

package/dist/core-CtVHRJGv.cjs

@@ -0,0 +1,199 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const __opentelemetry_api = require_chunk.__toESM(require("@opentelemetry/api"));
+const __opentelemetry_sdk_trace_base = require_chunk.__toESM(require("@opentelemetry/sdk-trace-base"));
+
+//#region src/instrumentation/core.ts
+const state = {
+	spanProcessor: null,
+	logProcessor: null,
+	initialized: false
+};
+/**
+* Create a span processor based on the strategy
+*/
+function createSpanProcessor(exporter, options) {
+	const { strategy,...config } = options;
+	if (strategy === "simple") return new __opentelemetry_sdk_trace_base.SimpleSpanProcessor(exporter);
+	return new __opentelemetry_sdk_trace_base.BatchSpanProcessor(exporter, {
+		maxQueueSize: config.maxQueueSize ?? 2048,
+		scheduledDelayMillis: config.scheduledDelayMillis ?? 5e3,
+		exportTimeoutMillis: config.exportTimeoutMillis ?? 3e4,
+		maxExportBatchSize: config.maxExportBatchSize ?? 512
+	});
+}
+/**
+* Get the recommended span processor strategy for an environment
+*/
+function getRecommendedStrategy(environment) {
+	switch (environment) {
+		case "lambda":
+		case "edge": return "simple";
+		default: return "batch";
+	}
+}
+/**
+* Set the global span processor for flush operations
+*/
+function setGlobalSpanProcessor(processor) {
+	state.spanProcessor = processor;
+	state.initialized = true;
+}
+/**
+* Set the global log processor for flush operations
+*/
+function setGlobalLogProcessor(processor) {
+	state.logProcessor = processor;
+}
+/**
+* Check if telemetry is initialized
+*/
+function isTelemetryInitialized() {
+	return state.initialized;
+}
+/**
+* Flush all pending telemetry data.
+* This is critical for serverless environments where the process may freeze.
+*
+* @example
+* ```typescript
+* // In a Lambda handler
+* export const handler = async (event, context) => {
+*   try {
+*     const result = await processRequest(event);
+*     return result;
+*   } finally {
+*     // Flush before Lambda freezes
+*     await flushTelemetry();
+*   }
+* };
+* ```
+*/
+async function flushTelemetry(timeoutMs = 3e4) {
+	const promises = [];
+	if (state.spanProcessor) promises.push(Promise.race([state.spanProcessor.forceFlush(), new Promise((_, reject) => setTimeout(() => reject(new Error("Span flush timeout")), timeoutMs))]).catch((error) => {
+		if (__opentelemetry_api.diag.debug) __opentelemetry_api.diag.debug(`Span flush error: ${error.message}`);
+	}));
+	if (state.logProcessor && typeof state.logProcessor.forceFlush === "function") promises.push(Promise.race([state.logProcessor.forceFlush(), new Promise((_, reject) => setTimeout(() => reject(new Error("Log flush timeout")), timeoutMs))]).catch((error) => {
+		if (__opentelemetry_api.diag.debug) __opentelemetry_api.diag.debug(`Log flush error: ${error.message}`);
+	}));
+	await Promise.all(promises);
+}
+/**
+* Shutdown all telemetry processors
+*/
+async function shutdownTelemetry() {
+	const promises = [];
+	if (state.spanProcessor) {
+		promises.push(state.spanProcessor.shutdown());
+		state.spanProcessor = null;
+	}
+	if (state.logProcessor && typeof state.logProcessor.shutdown === "function") {
+		promises.push(state.logProcessor.shutdown());
+		state.logProcessor = null;
+	}
+	state.initialized = false;
+	await Promise.all(promises);
+}
+/**
+* Enable debug logging for telemetry
+*/
+function enableTelemetryDebug() {
+	__opentelemetry_api.diag.setLogger(new __opentelemetry_api.DiagConsoleLogger(), __opentelemetry_api.DiagLogLevel.DEBUG);
+}
+/**
+* Wraps a handler function to ensure telemetry is flushed before returning.
+* Useful for Lambda handlers.
+*
+* @example
+* ```typescript
+* export const handler = withTelemetryFlush(async (event, context) => {
+*   // Your Lambda logic here
+*   return { statusCode: 200, body: 'OK' };
+* });
+* ```
+*/
+function withTelemetryFlush(handler) {
+	return async (event, context) => {
+		try {
+			return await handler(event, context);
+		} finally {
+			await flushTelemetry();
+		}
+	};
+}
+/**
+* Noop span processor for testing or when telemetry is disabled
+*/
+var NoopSpanProcessor = class {
+	forceFlush() {
+		return Promise.resolve();
+	}
+	onStart(_span) {}
+	onEnd(_span) {}
+	shutdown() {
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'NoopSpanProcessor', {
+  enumerable: true,
+  get: function () {
+    return NoopSpanProcessor;
+  }
+});
+Object.defineProperty(exports, 'createSpanProcessor', {
+  enumerable: true,
+  get: function () {
+    return createSpanProcessor;
+  }
+});
+Object.defineProperty(exports, 'enableTelemetryDebug', {
+  enumerable: true,
+  get: function () {
+    return enableTelemetryDebug;
+  }
+});
+Object.defineProperty(exports, 'flushTelemetry', {
+  enumerable: true,
+  get: function () {
+    return flushTelemetry;
+  }
+});
+Object.defineProperty(exports, 'getRecommendedStrategy', {
+  enumerable: true,
+  get: function () {
+    return getRecommendedStrategy;
+  }
+});
+Object.defineProperty(exports, 'isTelemetryInitialized', {
+  enumerable: true,
+  get: function () {
+    return isTelemetryInitialized;
+  }
+});
+Object.defineProperty(exports, 'setGlobalLogProcessor', {
+  enumerable: true,
+  get: function () {
+    return setGlobalLogProcessor;
+  }
+});
+Object.defineProperty(exports, 'setGlobalSpanProcessor', {
+  enumerable: true,
+  get: function () {
+    return setGlobalSpanProcessor;
+  }
+});
+Object.defineProperty(exports, 'shutdownTelemetry', {
+  enumerable: true,
+  get: function () {
+    return shutdownTelemetry;
+  }
+});
+Object.defineProperty(exports, 'withTelemetryFlush', {
+  enumerable: true,
+  get: function () {
+    return withTelemetryFlush;
+  }
+});
+//# sourceMappingURL=core-CtVHRJGv.cjs.map

package/dist/core-CtVHRJGv.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-CtVHRJGv.cjs","names":["state: TelemetryState","exporter: SpanExporter","options: SpanProcessorOptions","SimpleSpanProcessor","BatchSpanProcessor","environment: 'server' | 'lambda' | 'edge' | 'custom'","processor: SpanProcessor","processor: unknown","promises: Promise<void>[]","diag","DiagConsoleLogger","DiagLogLevel","handler: (event: TEvent, context: unknown) => Promise<TResult>","event: TEvent","context: unknown","_span: Span","_span: ReadableSpan"],"sources":["../src/instrumentation/core.ts"],"sourcesContent":["import { DiagConsoleLogger, DiagLogLevel, diag } from '@opentelemetry/api';\nimport {\n\tBatchSpanProcessor,\n\ttype ReadableSpan,\n\tSimpleSpanProcessor,\n\ttype Span,\n\ttype SpanExporter,\n\ttype SpanProcessor,\n} from '@opentelemetry/sdk-trace-base';\nimport type {\n\tSpanProcessorOptions,\n\tSpanProcessorStrategy,\n} from '../adapters/types';\n\n/**\n * Global telemetry state for flush operations\n */\ninterface TelemetryState {\n\tspanProcessor: SpanProcessor | null;\n\tlogProcessor: unknown | null;\n\tinitialized: boolean;\n}\n\nconst state: TelemetryState = {\n\tspanProcessor: null,\n\tlogProcessor: null,\n\tinitialized: false,\n};\n\n/**\n * Create a span processor based on the strategy\n */\nexport function createSpanProcessor(\n\texporter: SpanExporter,\n\toptions: SpanProcessorOptions,\n): SpanProcessor {\n\tconst { strategy, ...config } = options;\n\n\tif (strategy === 'simple') {\n\t\treturn new SimpleSpanProcessor(exporter);\n\t}\n\n\treturn new BatchSpanProcessor(exporter, {\n\t\tmaxQueueSize: config.maxQueueSize ?? 2048,\n\t\tscheduledDelayMillis: config.scheduledDelayMillis ?? 5000,\n\t\texportTimeoutMillis: config.exportTimeoutMillis ?? 30000,\n\t\tmaxExportBatchSize: config.maxExportBatchSize ?? 512,\n\t});\n}\n\n/**\n * Get the recommended span processor strategy for an environment\n */\nexport function getRecommendedStrategy(\n\tenvironment: 'server' | 'lambda' | 'edge' | 'custom',\n): SpanProcessorStrategy {\n\tswitch (environment) {\n\t\tcase 'lambda':\n\t\tcase 'edge':\n\t\t\t// Use simple processor for serverless - immediate export\n\t\t\treturn 'simple';\n\t\tdefault:\n\t\t\t// Use batch processor for long-running servers - efficient batching\n\t\t\treturn 'batch';\n\t}\n}\n\n/**\n * Set the global span processor for flush operations\n */\nexport function setGlobalSpanProcessor(processor: SpanProcessor): void {\n\tstate.spanProcessor = processor;\n\tstate.initialized = true;\n}\n\n/**\n * Set the global log processor for flush operations\n */\nexport function setGlobalLogProcessor(processor: unknown): void {\n\tstate.logProcessor = processor;\n}\n\n/**\n * Check if telemetry is initialized\n */\nexport function isTelemetryInitialized(): boolean {\n\treturn state.initialized;\n}\n\n/**\n * Flush all pending telemetry data.\n * This is critical for serverless environments where the process may freeze.\n *\n * @example\n * ```typescript\n * // In a Lambda handler\n * export const handler = async (event, context) => {\n *   try {\n *     const result = await processRequest(event);\n *     return result;\n *   } finally {\n *     // Flush before Lambda freezes\n *     await flushTelemetry();\n *   }\n * };\n * ```\n */\nexport async function flushTelemetry(timeoutMs = 30000): Promise<void> {\n\tconst promises: Promise<void>[] = [];\n\n\t// Flush span processor\n\tif (state.spanProcessor) {\n\t\tpromises.push(\n\t\t\tPromise.race([\n\t\t\t\tstate.spanProcessor.forceFlush(),\n\t\t\t\tnew Promise<void>((_, reject) =>\n\t\t\t\t\tsetTimeout(() => reject(new Error('Span flush timeout')), timeoutMs),\n\t\t\t\t),\n\t\t\t]).catch((error) => {\n\t\t\t\tif (diag.debug) {\n\t\t\t\t\tdiag.debug(`Span flush error: ${error.message}`);\n\t\t\t\t}\n\t\t\t}),\n\t\t);\n\t}\n\n\t// Flush log processor if it has forceFlush method\n\tif (\n\t\tstate.logProcessor &&\n\t\ttypeof (state.logProcessor as { forceFlush?: () => Promise<void> })\n\t\t\t.forceFlush === 'function'\n\t) {\n\t\tpromises.push(\n\t\t\tPromise.race([\n\t\t\t\t(\n\t\t\t\t\tstate.logProcessor as { forceFlush: () => Promise<void> }\n\t\t\t\t).forceFlush(),\n\t\t\t\tnew Promise<void>((_, reject) =>\n\t\t\t\t\tsetTimeout(() => reject(new Error('Log flush timeout')), timeoutMs),\n\t\t\t\t),\n\t\t\t]).catch((error) => {\n\t\t\t\tif (diag.debug) {\n\t\t\t\t\tdiag.debug(`Log flush error: ${error.message}`);\n\t\t\t\t}\n\t\t\t}),\n\t\t);\n\t}\n\n\tawait Promise.all(promises);\n}\n\n/**\n * Shutdown all telemetry processors\n */\nexport async function shutdownTelemetry(): Promise<void> {\n\tconst promises: Promise<void>[] = [];\n\n\tif (state.spanProcessor) {\n\t\tpromises.push(state.spanProcessor.shutdown());\n\t\tstate.spanProcessor = null;\n\t}\n\n\tif (\n\t\tstate.logProcessor &&\n\t\ttypeof (state.logProcessor as { shutdown?: () => Promise<void> })\n\t\t\t.shutdown === 'function'\n\t) {\n\t\tpromises.push(\n\t\t\t(state.logProcessor as { shutdown: () => Promise<void> }).shutdown(),\n\t\t);\n\t\tstate.logProcessor = null;\n\t}\n\n\tstate.initialized = false;\n\tawait Promise.all(promises);\n}\n\n/**\n * Enable debug logging for telemetry\n */\nexport function enableTelemetryDebug(): void {\n\tdiag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG);\n}\n\n/**\n * Wraps a handler function to ensure telemetry is flushed before returning.\n * Useful for Lambda handlers.\n *\n * @example\n * ```typescript\n * export const handler = withTelemetryFlush(async (event, context) => {\n *   // Your Lambda logic here\n *   return { statusCode: 200, body: 'OK' };\n * });\n * ```\n */\nexport function withTelemetryFlush<TEvent, TResult>(\n\thandler: (event: TEvent, context: unknown) => Promise<TResult>,\n): (event: TEvent, context: unknown) => Promise<TResult> {\n\treturn async (event: TEvent, context: unknown): Promise<TResult> => {\n\t\ttry {\n\t\t\treturn await handler(event, context);\n\t\t} finally {\n\t\t\tawait flushTelemetry();\n\t\t}\n\t};\n}\n\n/**\n * Noop span processor for testing or when telemetry is disabled\n */\nexport class NoopSpanProcessor implements SpanProcessor {\n\tforceFlush(): Promise<void> {\n\t\treturn Promise.resolve();\n\t}\n\n\tonStart(_span: Span): void {\n\t\t// noop\n\t}\n\n\tonEnd(_span: ReadableSpan): void {\n\t\t// noop\n\t}\n\n\tshutdown(): Promise<void> {\n\t\treturn Promise.resolve();\n\t}\n}\n"],"mappings":";;;;;AAuBA,MAAMA,QAAwB;CAC7B,eAAe;CACf,cAAc;CACd,aAAa;AACb;;;;AAKD,SAAgB,oBACfC,UACAC,SACgB;CAChB,MAAM,EAAE,SAAU,GAAG,QAAQ,GAAG;AAEhC,KAAI,aAAa,SAChB,QAAO,IAAIC,mDAAoB;AAGhC,QAAO,IAAIC,kDAAmB,UAAU;EACvC,cAAc,OAAO,gBAAgB;EACrC,sBAAsB,OAAO,wBAAwB;EACrD,qBAAqB,OAAO,uBAAuB;EACnD,oBAAoB,OAAO,sBAAsB;CACjD;AACD;;;;AAKD,SAAgB,uBACfC,aACwB;AACxB,SAAQ,aAAR;EACC,KAAK;EACL,KAAK,OAEJ,QAAO;EACR,QAEC,QAAO;CACR;AACD;;;;AAKD,SAAgB,uBAAuBC,WAAgC;AACtE,OAAM,gBAAgB;AACtB,OAAM,cAAc;AACpB;;;;AAKD,SAAgB,sBAAsBC,WAA0B;AAC/D,OAAM,eAAe;AACrB;;;;AAKD,SAAgB,yBAAkC;AACjD,QAAO,MAAM;AACb;;;;;;;;;;;;;;;;;;;AAoBD,eAAsB,eAAe,YAAY,KAAsB;CACtE,MAAMC,WAA4B,CAAE;AAGpC,KAAI,MAAM,cACT,UAAS,KACR,QAAQ,KAAK,CACZ,MAAM,cAAc,YAAY,EAChC,IAAI,QAAc,CAAC,GAAG,WACrB,WAAW,MAAM,OAAO,IAAI,MAAM,sBAAsB,EAAE,UAAU,CAErE,EAAC,CAAC,MAAM,CAAC,UAAU;AACnB,MAAIC,yBAAK,MACR,0BAAK,OAAO,oBAAoB,MAAM,QAAQ,EAAE;CAEjD,EAAC,CACF;AAIF,KACC,MAAM,uBACE,MAAM,aACZ,eAAe,WAEjB,UAAS,KACR,QAAQ,KAAK,CACZ,AACC,MAAM,aACL,YAAY,EACd,IAAI,QAAc,CAAC,GAAG,WACrB,WAAW,MAAM,OAAO,IAAI,MAAM,qBAAqB,EAAE,UAAU,CAEpE,EAAC,CAAC,MAAM,CAAC,UAAU;AACnB,MAAIA,yBAAK,MACR,0BAAK,OAAO,mBAAmB,MAAM,QAAQ,EAAE;CAEhD,EAAC,CACF;AAGF,OAAM,QAAQ,IAAI,SAAS;AAC3B;;;;AAKD,eAAsB,oBAAmC;CACxD,MAAMD,WAA4B,CAAE;AAEpC,KAAI,MAAM,eAAe;AACxB,WAAS,KAAK,MAAM,cAAc,UAAU,CAAC;AAC7C,QAAM,gBAAgB;CACtB;AAED,KACC,MAAM,uBACE,MAAM,aACZ,aAAa,YACd;AACD,WAAS,KACR,AAAC,MAAM,aAAmD,UAAU,CACpE;AACD,QAAM,eAAe;CACrB;AAED,OAAM,cAAc;AACpB,OAAM,QAAQ,IAAI,SAAS;AAC3B;;;;AAKD,SAAgB,uBAA6B;AAC5C,0BAAK,UAAU,IAAIE,yCAAqBC,iCAAa,MAAM;AAC3D;;;;;;;;;;;;;AAcD,SAAgB,mBACfC,SACwD;AACxD,QAAO,OAAOC,OAAeC,YAAuC;AACnE,MAAI;AACH,UAAO,MAAM,QAAQ,OAAO,QAAQ;EACpC,UAAS;AACT,SAAM,gBAAgB;EACtB;CACD;AACD;;;;AAKD,IAAa,oBAAb,MAAwD;CACvD,aAA4B;AAC3B,SAAO,QAAQ,SAAS;CACxB;CAED,QAAQC,OAAmB,CAE1B;CAED,MAAMC,OAA2B,CAEhC;CAED,WAA0B;AACzB,SAAO,QAAQ,SAAS;CACxB;AACD"}

package/dist/core-D6hJ6exL.mjs

@@ -0,0 +1,139 @@
+import { DiagConsoleLogger, DiagLogLevel, diag } from "@opentelemetry/api";
+import { BatchSpanProcessor, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+
+//#region src/instrumentation/core.ts
+const state = {
+	spanProcessor: null,
+	logProcessor: null,
+	initialized: false
+};
+/**
+* Create a span processor based on the strategy
+*/
+function createSpanProcessor(exporter, options) {
+	const { strategy,...config } = options;
+	if (strategy === "simple") return new SimpleSpanProcessor(exporter);
+	return new BatchSpanProcessor(exporter, {
+		maxQueueSize: config.maxQueueSize ?? 2048,
+		scheduledDelayMillis: config.scheduledDelayMillis ?? 5e3,
+		exportTimeoutMillis: config.exportTimeoutMillis ?? 3e4,
+		maxExportBatchSize: config.maxExportBatchSize ?? 512
+	});
+}
+/**
+* Get the recommended span processor strategy for an environment
+*/
+function getRecommendedStrategy(environment) {
+	switch (environment) {
+		case "lambda":
+		case "edge": return "simple";
+		default: return "batch";
+	}
+}
+/**
+* Set the global span processor for flush operations
+*/
+function setGlobalSpanProcessor(processor) {
+	state.spanProcessor = processor;
+	state.initialized = true;
+}
+/**
+* Set the global log processor for flush operations
+*/
+function setGlobalLogProcessor(processor) {
+	state.logProcessor = processor;
+}
+/**
+* Check if telemetry is initialized
+*/
+function isTelemetryInitialized() {
+	return state.initialized;
+}
+/**
+* Flush all pending telemetry data.
+* This is critical for serverless environments where the process may freeze.
+*
+* @example
+* ```typescript
+* // In a Lambda handler
+* export const handler = async (event, context) => {
+*   try {
+*     const result = await processRequest(event);
+*     return result;
+*   } finally {
+*     // Flush before Lambda freezes
+*     await flushTelemetry();
+*   }
+* };
+* ```
+*/
+async function flushTelemetry(timeoutMs = 3e4) {
+	const promises = [];
+	if (state.spanProcessor) promises.push(Promise.race([state.spanProcessor.forceFlush(), new Promise((_, reject) => setTimeout(() => reject(new Error("Span flush timeout")), timeoutMs))]).catch((error) => {
+		if (diag.debug) diag.debug(`Span flush error: ${error.message}`);
+	}));
+	if (state.logProcessor && typeof state.logProcessor.forceFlush === "function") promises.push(Promise.race([state.logProcessor.forceFlush(), new Promise((_, reject) => setTimeout(() => reject(new Error("Log flush timeout")), timeoutMs))]).catch((error) => {
+		if (diag.debug) diag.debug(`Log flush error: ${error.message}`);
+	}));
+	await Promise.all(promises);
+}
+/**
+* Shutdown all telemetry processors
+*/
+async function shutdownTelemetry() {
+	const promises = [];
+	if (state.spanProcessor) {
+		promises.push(state.spanProcessor.shutdown());
+		state.spanProcessor = null;
+	}
+	if (state.logProcessor && typeof state.logProcessor.shutdown === "function") {
+		promises.push(state.logProcessor.shutdown());
+		state.logProcessor = null;
+	}
+	state.initialized = false;
+	await Promise.all(promises);
+}
+/**
+* Enable debug logging for telemetry
+*/
+function enableTelemetryDebug() {
+	diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG);
+}
+/**
+* Wraps a handler function to ensure telemetry is flushed before returning.
+* Useful for Lambda handlers.
+*
+* @example
+* ```typescript
+* export const handler = withTelemetryFlush(async (event, context) => {
+*   // Your Lambda logic here
+*   return { statusCode: 200, body: 'OK' };
+* });
+* ```
+*/
+function withTelemetryFlush(handler) {
+	return async (event, context$1) => {
+		try {
+			return await handler(event, context$1);
+		} finally {
+			await flushTelemetry();
+		}
+	};
+}
+/**
+* Noop span processor for testing or when telemetry is disabled
+*/
+var NoopSpanProcessor = class {
+	forceFlush() {
+		return Promise.resolve();
+	}
+	onStart(_span) {}
+	onEnd(_span) {}
+	shutdown() {
+		return Promise.resolve();
+	}
+};
+
+//#endregion
+export { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush };
+//# sourceMappingURL=core-D6hJ6exL.mjs.map

package/dist/core-D6hJ6exL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-D6hJ6exL.mjs","names":["state: TelemetryState","exporter: SpanExporter","options: SpanProcessorOptions","environment: 'server' | 'lambda' | 'edge' | 'custom'","processor: SpanProcessor","processor: unknown","promises: Promise<void>[]","handler: (event: TEvent, context: unknown) => Promise<TResult>","event: TEvent","context: unknown","context","_span: Span","_span: ReadableSpan"],"sources":["../src/instrumentation/core.ts"],"sourcesContent":["import { DiagConsoleLogger, DiagLogLevel, diag } from '@opentelemetry/api';\nimport {\n\tBatchSpanProcessor,\n\ttype ReadableSpan,\n\tSimpleSpanProcessor,\n\ttype Span,\n\ttype SpanExporter,\n\ttype SpanProcessor,\n} from '@opentelemetry/sdk-trace-base';\nimport type {\n\tSpanProcessorOptions,\n\tSpanProcessorStrategy,\n} from '../adapters/types';\n\n/**\n * Global telemetry state for flush operations\n */\ninterface TelemetryState {\n\tspanProcessor: SpanProcessor | null;\n\tlogProcessor: unknown | null;\n\tinitialized: boolean;\n}\n\nconst state: TelemetryState = {\n\tspanProcessor: null,\n\tlogProcessor: null,\n\tinitialized: false,\n};\n\n/**\n * Create a span processor based on the strategy\n */\nexport function createSpanProcessor(\n\texporter: SpanExporter,\n\toptions: SpanProcessorOptions,\n): SpanProcessor {\n\tconst { strategy, ...config } = options;\n\n\tif (strategy === 'simple') {\n\t\treturn new SimpleSpanProcessor(exporter);\n\t}\n\n\treturn new BatchSpanProcessor(exporter, {\n\t\tmaxQueueSize: config.maxQueueSize ?? 2048,\n\t\tscheduledDelayMillis: config.scheduledDelayMillis ?? 5000,\n\t\texportTimeoutMillis: config.exportTimeoutMillis ?? 30000,\n\t\tmaxExportBatchSize: config.maxExportBatchSize ?? 512,\n\t});\n}\n\n/**\n * Get the recommended span processor strategy for an environment\n */\nexport function getRecommendedStrategy(\n\tenvironment: 'server' | 'lambda' | 'edge' | 'custom',\n): SpanProcessorStrategy {\n\tswitch (environment) {\n\t\tcase 'lambda':\n\t\tcase 'edge':\n\t\t\t// Use simple processor for serverless - immediate export\n\t\t\treturn 'simple';\n\t\tdefault:\n\t\t\t// Use batch processor for long-running servers - efficient batching\n\t\t\treturn 'batch';\n\t}\n}\n\n/**\n * Set the global span processor for flush operations\n */\nexport function setGlobalSpanProcessor(processor: SpanProcessor): void {\n\tstate.spanProcessor = processor;\n\tstate.initialized = true;\n}\n\n/**\n * Set the global log processor for flush operations\n */\nexport function setGlobalLogProcessor(processor: unknown): void {\n\tstate.logProcessor = processor;\n}\n\n/**\n * Check if telemetry is initialized\n */\nexport function isTelemetryInitialized(): boolean {\n\treturn state.initialized;\n}\n\n/**\n * Flush all pending telemetry data.\n * This is critical for serverless environments where the process may freeze.\n *\n * @example\n * ```typescript\n * // In a Lambda handler\n * export const handler = async (event, context) => {\n *   try {\n *     const result = await processRequest(event);\n *     return result;\n *   } finally {\n *     // Flush before Lambda freezes\n *     await flushTelemetry();\n *   }\n * };\n * ```\n */\nexport async function flushTelemetry(timeoutMs = 30000): Promise<void> {\n\tconst promises: Promise<void>[] = [];\n\n\t// Flush span processor\n\tif (state.spanProcessor) {\n\t\tpromises.push(\n\t\t\tPromise.race([\n\t\t\t\tstate.spanProcessor.forceFlush(),\n\t\t\t\tnew Promise<void>((_, reject) =>\n\t\t\t\t\tsetTimeout(() => reject(new Error('Span flush timeout')), timeoutMs),\n\t\t\t\t),\n\t\t\t]).catch((error) => {\n\t\t\t\tif (diag.debug) {\n\t\t\t\t\tdiag.debug(`Span flush error: ${error.message}`);\n\t\t\t\t}\n\t\t\t}),\n\t\t);\n\t}\n\n\t// Flush log processor if it has forceFlush method\n\tif (\n\t\tstate.logProcessor &&\n\t\ttypeof (state.logProcessor as { forceFlush?: () => Promise<void> })\n\t\t\t.forceFlush === 'function'\n\t) {\n\t\tpromises.push(\n\t\t\tPromise.race([\n\t\t\t\t(\n\t\t\t\t\tstate.logProcessor as { forceFlush: () => Promise<void> }\n\t\t\t\t).forceFlush(),\n\t\t\t\tnew Promise<void>((_, reject) =>\n\t\t\t\t\tsetTimeout(() => reject(new Error('Log flush timeout')), timeoutMs),\n\t\t\t\t),\n\t\t\t]).catch((error) => {\n\t\t\t\tif (diag.debug) {\n\t\t\t\t\tdiag.debug(`Log flush error: ${error.message}`);\n\t\t\t\t}\n\t\t\t}),\n\t\t);\n\t}\n\n\tawait Promise.all(promises);\n}\n\n/**\n * Shutdown all telemetry processors\n */\nexport async function shutdownTelemetry(): Promise<void> {\n\tconst promises: Promise<void>[] = [];\n\n\tif (state.spanProcessor) {\n\t\tpromises.push(state.spanProcessor.shutdown());\n\t\tstate.spanProcessor = null;\n\t}\n\n\tif (\n\t\tstate.logProcessor &&\n\t\ttypeof (state.logProcessor as { shutdown?: () => Promise<void> })\n\t\t\t.shutdown === 'function'\n\t) {\n\t\tpromises.push(\n\t\t\t(state.logProcessor as { shutdown: () => Promise<void> }).shutdown(),\n\t\t);\n\t\tstate.logProcessor = null;\n\t}\n\n\tstate.initialized = false;\n\tawait Promise.all(promises);\n}\n\n/**\n * Enable debug logging for telemetry\n */\nexport function enableTelemetryDebug(): void {\n\tdiag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG);\n}\n\n/**\n * Wraps a handler function to ensure telemetry is flushed before returning.\n * Useful for Lambda handlers.\n *\n * @example\n * ```typescript\n * export const handler = withTelemetryFlush(async (event, context) => {\n *   // Your Lambda logic here\n *   return { statusCode: 200, body: 'OK' };\n * });\n * ```\n */\nexport function withTelemetryFlush<TEvent, TResult>(\n\thandler: (event: TEvent, context: unknown) => Promise<TResult>,\n): (event: TEvent, context: unknown) => Promise<TResult> {\n\treturn async (event: TEvent, context: unknown): Promise<TResult> => {\n\t\ttry {\n\t\t\treturn await handler(event, context);\n\t\t} finally {\n\t\t\tawait flushTelemetry();\n\t\t}\n\t};\n}\n\n/**\n * Noop span processor for testing or when telemetry is disabled\n */\nexport class NoopSpanProcessor implements SpanProcessor {\n\tforceFlush(): Promise<void> {\n\t\treturn Promise.resolve();\n\t}\n\n\tonStart(_span: Span): void {\n\t\t// noop\n\t}\n\n\tonEnd(_span: ReadableSpan): void {\n\t\t// noop\n\t}\n\n\tshutdown(): Promise<void> {\n\t\treturn Promise.resolve();\n\t}\n}\n"],"mappings":";;;;AAuBA,MAAMA,QAAwB;CAC7B,eAAe;CACf,cAAc;CACd,aAAa;AACb;;;;AAKD,SAAgB,oBACfC,UACAC,SACgB;CAChB,MAAM,EAAE,SAAU,GAAG,QAAQ,GAAG;AAEhC,KAAI,aAAa,SAChB,QAAO,IAAI,oBAAoB;AAGhC,QAAO,IAAI,mBAAmB,UAAU;EACvC,cAAc,OAAO,gBAAgB;EACrC,sBAAsB,OAAO,wBAAwB;EACrD,qBAAqB,OAAO,uBAAuB;EACnD,oBAAoB,OAAO,sBAAsB;CACjD;AACD;;;;AAKD,SAAgB,uBACfC,aACwB;AACxB,SAAQ,aAAR;EACC,KAAK;EACL,KAAK,OAEJ,QAAO;EACR,QAEC,QAAO;CACR;AACD;;;;AAKD,SAAgB,uBAAuBC,WAAgC;AACtE,OAAM,gBAAgB;AACtB,OAAM,cAAc;AACpB;;;;AAKD,SAAgB,sBAAsBC,WAA0B;AAC/D,OAAM,eAAe;AACrB;;;;AAKD,SAAgB,yBAAkC;AACjD,QAAO,MAAM;AACb;;;;;;;;;;;;;;;;;;;AAoBD,eAAsB,eAAe,YAAY,KAAsB;CACtE,MAAMC,WAA4B,CAAE;AAGpC,KAAI,MAAM,cACT,UAAS,KACR,QAAQ,KAAK,CACZ,MAAM,cAAc,YAAY,EAChC,IAAI,QAAc,CAAC,GAAG,WACrB,WAAW,MAAM,OAAO,IAAI,MAAM,sBAAsB,EAAE,UAAU,CAErE,EAAC,CAAC,MAAM,CAAC,UAAU;AACnB,MAAI,KAAK,MACR,MAAK,OAAO,oBAAoB,MAAM,QAAQ,EAAE;CAEjD,EAAC,CACF;AAIF,KACC,MAAM,uBACE,MAAM,aACZ,eAAe,WAEjB,UAAS,KACR,QAAQ,KAAK,CACZ,AACC,MAAM,aACL,YAAY,EACd,IAAI,QAAc,CAAC,GAAG,WACrB,WAAW,MAAM,OAAO,IAAI,MAAM,qBAAqB,EAAE,UAAU,CAEpE,EAAC,CAAC,MAAM,CAAC,UAAU;AACnB,MAAI,KAAK,MACR,MAAK,OAAO,mBAAmB,MAAM,QAAQ,EAAE;CAEhD,EAAC,CACF;AAGF,OAAM,QAAQ,IAAI,SAAS;AAC3B;;;;AAKD,eAAsB,oBAAmC;CACxD,MAAMA,WAA4B,CAAE;AAEpC,KAAI,MAAM,eAAe;AACxB,WAAS,KAAK,MAAM,cAAc,UAAU,CAAC;AAC7C,QAAM,gBAAgB;CACtB;AAED,KACC,MAAM,uBACE,MAAM,aACZ,aAAa,YACd;AACD,WAAS,KACR,AAAC,MAAM,aAAmD,UAAU,CACpE;AACD,QAAM,eAAe;CACrB;AAED,OAAM,cAAc;AACpB,OAAM,QAAQ,IAAI,SAAS;AAC3B;;;;AAKD,SAAgB,uBAA6B;AAC5C,MAAK,UAAU,IAAI,qBAAqB,aAAa,MAAM;AAC3D;;;;;;;;;;;;;AAcD,SAAgB,mBACfC,SACwD;AACxD,QAAO,OAAOC,OAAeC,cAAuC;AACnE,MAAI;AACH,UAAO,MAAM,QAAQ,OAAOC,UAAQ;EACpC,UAAS;AACT,SAAM,gBAAgB;EACtB;CACD;AACD;;;;AAKD,IAAa,oBAAb,MAAwD;CACvD,aAA4B;AAC3B,SAAO,QAAQ,SAAS;CACxB;CAED,QAAQC,OAAmB,CAE1B;CAED,MAAMC,OAA2B,CAEhC;CAED,WAA0B;AACzB,SAAO,QAAQ,SAAS;CACxB;AACD"}

package/dist/core.cjs

@@ -1,22 +1,22 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_instrumentation_core = require("./instrumentation/core.cjs");
-const require_instrumentation_tracing = require("./instrumentation/tracing.cjs");
-exports.NoopSpanProcessor = require_instrumentation_core.NoopSpanProcessor;
-exports.addSpanEvent = require_instrumentation_tracing.addSpanEvent;
-exports.createSpan = require_instrumentation_tracing.createSpan;
-exports.createSpanProcessor = require_instrumentation_core.createSpanProcessor;
-exports.enableTelemetryDebug = require_instrumentation_core.enableTelemetryDebug;
-exports.flushTelemetry = require_instrumentation_core.flushTelemetry;
-exports.getActiveSpan = require_instrumentation_tracing.getActiveSpan;
-exports.getRecommendedStrategy = require_instrumentation_core.getRecommendedStrategy;
-exports.getSpanId = require_instrumentation_tracing.getSpanId;
-exports.getTraceId = require_instrumentation_tracing.getTraceId;
-exports.isTelemetryInitialized = require_instrumentation_core.isTelemetryInitialized;
-exports.recordException = require_instrumentation_tracing.recordException;
-exports.setGlobalLogProcessor = require_instrumentation_core.setGlobalLogProcessor;
-exports.setGlobalSpanProcessor = require_instrumentation_core.setGlobalSpanProcessor;
-exports.setSpanAttributes = require_instrumentation_tracing.setSpanAttributes;
-exports.shutdownTelemetry = require_instrumentation_core.shutdownTelemetry;
-exports.withSpan = require_instrumentation_tracing.withSpan;
-exports.withSpanSync = require_instrumentation_tracing.withSpanSync;
-exports.withTelemetryFlush = require_instrumentation_core.withTelemetryFlush;
+const require_core = require('./core-CtVHRJGv.cjs');
+const require_tracing = require('./tracing-Bt1zWRlb.cjs');
+
+exports.NoopSpanProcessor = require_core.NoopSpanProcessor;
+exports.addSpanEvent = require_tracing.addSpanEvent;
+exports.createSpan = require_tracing.createSpan;
+exports.createSpanProcessor = require_core.createSpanProcessor;
+exports.enableTelemetryDebug = require_core.enableTelemetryDebug;
+exports.flushTelemetry = require_core.flushTelemetry;
+exports.getActiveSpan = require_tracing.getActiveSpan;
+exports.getRecommendedStrategy = require_core.getRecommendedStrategy;
+exports.getSpanId = require_tracing.getSpanId;
+exports.getTraceId = require_tracing.getTraceId;
+exports.isTelemetryInitialized = require_core.isTelemetryInitialized;
+exports.recordException = require_tracing.recordException;
+exports.setGlobalLogProcessor = require_core.setGlobalLogProcessor;
+exports.setGlobalSpanProcessor = require_core.setGlobalSpanProcessor;
+exports.setSpanAttributes = require_tracing.setSpanAttributes;
+exports.shutdownTelemetry = require_core.shutdownTelemetry;
+exports.withSpan = require_tracing.withSpan;
+exports.withSpanSync = require_tracing.withSpanSync;
+exports.withTelemetryFlush = require_core.withTelemetryFlush;

package/dist/core.d.cts

@@ -1,4 +1,4 @@
-import { AdapterConfig, AdapterErrorContext, AdapterLifecycle, AdapterRequestContext, AdapterResponseContext, HonoAdapterConfig, HonoContextWithTelescope, LambdaAdapterConfig, SpanProcessorOptions, SpanProcessorStrategy, TelescopeAdapter, TelescopeEnvironment, TelescopeHonoContext, TelescopeHonoVariables } from "./adapters/types.cjs";
-import { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush } from "./instrumentation/core.cjs";
-import { addSpanEvent, createSpan, getActiveSpan, getSpanId, getTraceId, recordException, setSpanAttributes, withSpan, withSpanSync } from "./instrumentation/tracing.cjs";
-export { type AdapterConfig, type AdapterErrorContext, type AdapterLifecycle, type AdapterRequestContext, type AdapterResponseContext, type HonoAdapterConfig, type HonoContextWithTelescope, type LambdaAdapterConfig, NoopSpanProcessor, type SpanProcessorOptions, type SpanProcessorStrategy, type TelescopeAdapter, type TelescopeEnvironment, type TelescopeHonoContext, type TelescopeHonoVariables, addSpanEvent, createSpan, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getActiveSpan, getRecommendedStrategy, getSpanId, getTraceId, isTelemetryInitialized, recordException, setGlobalLogProcessor, setGlobalSpanProcessor, setSpanAttributes, shutdownTelemetry, withSpan, withSpanSync, withTelemetryFlush };
+import { AdapterConfig, AdapterErrorContext, AdapterLifecycle, AdapterRequestContext, AdapterResponseContext, HonoAdapterConfig, HonoContextWithTelescope, LambdaAdapterConfig, SpanProcessorOptions, SpanProcessorStrategy, TelescopeAdapter, TelescopeEnvironment, TelescopeHonoContext, TelescopeHonoVariables } from "./types-BRzW1NM8.cjs";
+import { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush } from "./core-B4Jpia5H.cjs";
+import { addSpanEvent, createSpan, getActiveSpan, getSpanId, getTraceId, recordException, setSpanAttributes, withSpan, withSpanSync } from "./tracing-BX8uY2nR.cjs";
+export { AdapterConfig, AdapterErrorContext, AdapterLifecycle, AdapterRequestContext, AdapterResponseContext, HonoAdapterConfig, HonoContextWithTelescope, LambdaAdapterConfig, NoopSpanProcessor, SpanProcessorOptions, SpanProcessorStrategy, TelescopeAdapter, TelescopeEnvironment, TelescopeHonoContext, TelescopeHonoVariables, addSpanEvent, createSpan, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getActiveSpan, getRecommendedStrategy, getSpanId, getTraceId, isTelemetryInitialized, recordException, setGlobalLogProcessor, setGlobalSpanProcessor, setSpanAttributes, shutdownTelemetry, withSpan, withSpanSync, withTelemetryFlush };

package/dist/core.d.mts

@@ -1,4 +1,4 @@
-import { AdapterConfig, AdapterErrorContext, AdapterLifecycle, AdapterRequestContext, AdapterResponseContext, HonoAdapterConfig, HonoContextWithTelescope, LambdaAdapterConfig, SpanProcessorOptions, SpanProcessorStrategy, TelescopeAdapter, TelescopeEnvironment, TelescopeHonoContext, TelescopeHonoVariables } from "./adapters/types.mjs";
-import { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush } from "./instrumentation/core.mjs";
-import { addSpanEvent, createSpan, getActiveSpan, getSpanId, getTraceId, recordException, setSpanAttributes, withSpan, withSpanSync } from "./instrumentation/tracing.mjs";
-export { type AdapterConfig, type AdapterErrorContext, type AdapterLifecycle, type AdapterRequestContext, type AdapterResponseContext, type HonoAdapterConfig, type HonoContextWithTelescope, type LambdaAdapterConfig, NoopSpanProcessor, type SpanProcessorOptions, type SpanProcessorStrategy, type TelescopeAdapter, type TelescopeEnvironment, type TelescopeHonoContext, type TelescopeHonoVariables, addSpanEvent, createSpan, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getActiveSpan, getRecommendedStrategy, getSpanId, getTraceId, isTelemetryInitialized, recordException, setGlobalLogProcessor, setGlobalSpanProcessor, setSpanAttributes, shutdownTelemetry, withSpan, withSpanSync, withTelemetryFlush };
+import { AdapterConfig, AdapterErrorContext, AdapterLifecycle, AdapterRequestContext, AdapterResponseContext, HonoAdapterConfig, HonoContextWithTelescope, LambdaAdapterConfig, SpanProcessorOptions, SpanProcessorStrategy, TelescopeAdapter, TelescopeEnvironment, TelescopeHonoContext, TelescopeHonoVariables } from "./types-BzQ78Efw.mjs";
+import { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush } from "./core--quSp5Qr.mjs";
+import { addSpanEvent, createSpan, getActiveSpan, getSpanId, getTraceId, recordException, setSpanAttributes, withSpan, withSpanSync } from "./tracing-PnECEbEu.mjs";
+export { AdapterConfig, AdapterErrorContext, AdapterLifecycle, AdapterRequestContext, AdapterResponseContext, HonoAdapterConfig, HonoContextWithTelescope, LambdaAdapterConfig, NoopSpanProcessor, SpanProcessorOptions, SpanProcessorStrategy, TelescopeAdapter, TelescopeEnvironment, TelescopeHonoContext, TelescopeHonoVariables, addSpanEvent, createSpan, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getActiveSpan, getRecommendedStrategy, getSpanId, getTraceId, isTelemetryInitialized, recordException, setGlobalLogProcessor, setGlobalSpanProcessor, setSpanAttributes, shutdownTelemetry, withSpan, withSpanSync, withTelemetryFlush };

package/dist/core.mjs

@@ -1,3 +1,4 @@
-import { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush } from "./instrumentation/core.mjs";
-import { addSpanEvent, createSpan, getActiveSpan, getSpanId, getTraceId, recordException, setSpanAttributes, withSpan, withSpanSync } from "./instrumentation/tracing.mjs";
-export { NoopSpanProcessor, addSpanEvent, createSpan, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getActiveSpan, getRecommendedStrategy, getSpanId, getTraceId, isTelemetryInitialized, recordException, setGlobalLogProcessor, setGlobalSpanProcessor, setSpanAttributes, shutdownTelemetry, withSpan, withSpanSync, withTelemetryFlush };
+import { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush } from "./core-D6hJ6exL.mjs";
+import { addSpanEvent, createSpan, getActiveSpan, getSpanId, getTraceId, recordException, setSpanAttributes, withSpan, withSpanSync } from "./tracing-Cijm_5NI.mjs";
+
+export { NoopSpanProcessor, addSpanEvent, createSpan, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getActiveSpan, getRecommendedStrategy, getSpanId, getTraceId, isTelemetryInitialized, recordException, setGlobalLogProcessor, setGlobalSpanProcessor, setSpanAttributes, shutdownTelemetry, withSpan, withSpanSync, withTelemetryFlush };

package/dist/hono--uKQ7Jgi.d.mts

@@ -0,0 +1,71 @@
+import { Span } from "@opentelemetry/api";
+import { Context as Context$1, MiddlewareHandler } from "hono";
+
+//#region src/instrumentation/hono.d.ts
+
+/**
+ * Options for the Hono telemetry middleware
+ */
+interface HonoTelemetryMiddlewareOptions {
+  /**
+   * Whether to record request body as span attribute
+   * @default false
+   */
+  recordBody?: boolean;
+  /**
+   * Whether to record response body as span attribute
+   * @default false
+   */
+  recordResponseBody?: boolean;
+  /**
+   * Custom function to extract user ID from context
+   */
+  getUserId?: (c: Context$1) => string | undefined;
+  /**
+   * Paths to skip tracing (supports wildcards)
+   */
+  ignorePaths?: string[];
+  /**
+   * Whether to skip tracing for this request
+   */
+  shouldSkip?: (c: Context$1) => boolean;
+}
+/**
+ * Get the current span from Hono context
+ */
+declare function getSpanFromContext(c: Context$1): Span | undefined;
+/**
+ * Get the current trace context from Hono context
+ */
+declare function getTraceContextFromHono(c: Context$1): any;
+/**
+ * Create a telemetry middleware for Hono applications
+ *
+ * @example
+ * ```typescript
+ * import { honoTelemetryMiddleware } from '@geekmidas/telescope/instrumentation';
+ *
+ * const app = new Hono();
+ * app.use('*', honoTelemetryMiddleware());
+ * ```
+ */
+declare function honoTelemetryMiddleware(options?: HonoTelemetryMiddlewareOptions): MiddlewareHandler;
+/**
+ * Run a function within the span context from Hono context
+ *
+ * @example
+ * ```typescript
+ * app.get('/api/users', async (c) => {
+ *   return withHonoSpanContext(c, async () => {
+ *     // Any spans created here will be children of the request span
+ *     const users = await fetchUsers();
+ *     return c.json(users);
+ *   });
+ * });
+ * ```
+ */
+declare function withHonoSpanContext<T>(c: Context$1, fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=hono.d.ts.map
+//#endregion
+export { HonoTelemetryMiddlewareOptions, getSpanFromContext, getTraceContextFromHono, honoTelemetryMiddleware, withHonoSpanContext };
+//# sourceMappingURL=hono--uKQ7Jgi.d.mts.map

package/dist/hono--uKQ7Jgi.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono--uKQ7Jgi.d.mts","names":[],"sources":["../src/instrumentation/hono.ts"],"sourcesContent":[],"mappings":";;;;;AAuDA;;;AAAgD,UApC/B,8BAAA,CAoC+B;EAAI;AAOpD;AAeA;;EAAuC,UAC7B,CAAA,EAAA,OAAA;EAAmC;AACzB;AAqLpB;;EAAyC,kBACrC,CAAA,EAAA,OAAA;EAAO;;;EAEC,SAAT,CAAA,EAAA,CAAA,CAAA,EApOc,SAoOd,EAAA,GAAA,MAAA,GAAA,SAAA;EAAO;;;;;;;mBA1NQ;;;;;iBAUF,kBAAA,IAAsB,YAAU;;;;iBAOhC,uBAAA,IAA2B;;;;;;;;;;;;iBAe3B,uBAAA,WACN,iCACP;;;;;;;;;;;;;;;iBAqLmB,0BAClB,qBACO,QAAQ,KAChB,QAAQ"}