@geekmidas/telescope 10.0.0-alpha.99 → 10.0.0

package/dist/instrumentation/core.cjs

@@ -1,148 +1,12 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let _opentelemetry_api = require("@opentelemetry/api");
-let _opentelemetry_sdk_trace_base = 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(/* @__PURE__ */ 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(/* @__PURE__ */ 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
-exports.NoopSpanProcessor = NoopSpanProcessor;
-exports.createSpanProcessor = createSpanProcessor;
-exports.enableTelemetryDebug = enableTelemetryDebug;
-exports.flushTelemetry = flushTelemetry;
-exports.getRecommendedStrategy = getRecommendedStrategy;
-exports.isTelemetryInitialized = isTelemetryInitialized;
-exports.setGlobalLogProcessor = setGlobalLogProcessor;
-exports.setGlobalSpanProcessor = setGlobalSpanProcessor;
-exports.shutdownTelemetry = shutdownTelemetry;
-exports.withTelemetryFlush = withTelemetryFlush;
+const require_core = require('../core-CtVHRJGv.cjs');
 
-//# sourceMappingURL=core.cjs.map
+exports.NoopSpanProcessor = require_core.NoopSpanProcessor;
+exports.createSpanProcessor = require_core.createSpanProcessor;
+exports.enableTelemetryDebug = require_core.enableTelemetryDebug;
+exports.flushTelemetry = require_core.flushTelemetry;
+exports.getRecommendedStrategy = require_core.getRecommendedStrategy;
+exports.isTelemetryInitialized = require_core.isTelemetryInitialized;
+exports.setGlobalLogProcessor = require_core.setGlobalLogProcessor;
+exports.setGlobalSpanProcessor = require_core.setGlobalSpanProcessor;
+exports.shutdownTelemetry = require_core.shutdownTelemetry;
+exports.withTelemetryFlush = require_core.withTelemetryFlush;

package/dist/instrumentation/core.d.cts

@@ -1,74 +1,3 @@
-import { SpanProcessorOptions, SpanProcessorStrategy } from "../adapters/types.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
- */
-export declare function createSpanProcessor(exporter: SpanExporter, options: SpanProcessorOptions): SpanProcessor;
-/**
- * Get the recommended span processor strategy for an environment
- */
-export declare function getRecommendedStrategy(environment: 'server' | 'lambda' | 'edge' | 'custom'): SpanProcessorStrategy;
-/**
- * Set the global span processor for flush operations
- */
-export declare function setGlobalSpanProcessor(processor: SpanProcessor): void;
-/**
- * Set the global log processor for flush operations
- */
-export declare function setGlobalLogProcessor(processor: unknown): void;
-/**
- * Check if telemetry is initialized
- */
-export 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();
- *   }
- * };
- * ```
- */
-export declare function flushTelemetry(timeoutMs?: number): Promise<void>;
-/**
- * Shutdown all telemetry processors
- */
-export declare function shutdownTelemetry(): Promise<void>;
-/**
- * Enable debug logging for telemetry
- */
-export 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' };
- * });
- * ```
- */
-export 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
- */
-export declare class NoopSpanProcessor implements SpanProcessor {
-  forceFlush(): Promise<void>;
-  onStart(_span: Span): void;
-  onEnd(_span: ReadableSpan): void;
-  shutdown(): Promise<void>;
-}
-//#endregion
-//# sourceMappingURL=core.d.cts.map
+import "../types-BRzW1NM8.cjs";
+import { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush } from "../core-B4Jpia5H.cjs";
+export { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush };

package/dist/instrumentation/core.d.mts

@@ -1,74 +1,3 @@
-import { SpanProcessorOptions, SpanProcessorStrategy } from "../adapters/types.mjs";
-import { ReadableSpan, Span, SpanExporter, SpanProcessor } from "@opentelemetry/sdk-trace-base";
-//#region src/instrumentation/core.d.ts
-/**
- * Create a span processor based on the strategy
- */
-export declare function createSpanProcessor(exporter: SpanExporter, options: SpanProcessorOptions): SpanProcessor;
-/**
- * Get the recommended span processor strategy for an environment
- */
-export declare function getRecommendedStrategy(environment: 'server' | 'lambda' | 'edge' | 'custom'): SpanProcessorStrategy;
-/**
- * Set the global span processor for flush operations
- */
-export declare function setGlobalSpanProcessor(processor: SpanProcessor): void;
-/**
- * Set the global log processor for flush operations
- */
-export declare function setGlobalLogProcessor(processor: unknown): void;
-/**
- * Check if telemetry is initialized
- */
-export 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();
- *   }
- * };
- * ```
- */
-export declare function flushTelemetry(timeoutMs?: number): Promise<void>;
-/**
- * Shutdown all telemetry processors
- */
-export declare function shutdownTelemetry(): Promise<void>;
-/**
- * Enable debug logging for telemetry
- */
-export 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' };
- * });
- * ```
- */
-export 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
- */
-export declare class NoopSpanProcessor implements SpanProcessor {
-  forceFlush(): Promise<void>;
-  onStart(_span: Span): void;
-  onEnd(_span: ReadableSpan): void;
-  shutdown(): Promise<void>;
-}
-//#endregion
-//# sourceMappingURL=core.d.mts.map
+import "../types-BzQ78Efw.mjs";
+import { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush } from "../core--quSp5Qr.mjs";
+export { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush };

package/dist/instrumentation/core.mjs

@@ -1,138 +1,3 @@
-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(/* @__PURE__ */ 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(/* @__PURE__ */ 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) => {
-		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
-export { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush };
+import { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush } from "../core-D6hJ6exL.mjs";
 
-//# sourceMappingURL=core.mjs.map
+export { NoopSpanProcessor, createSpanProcessor, enableTelemetryDebug, flushTelemetry, getRecommendedStrategy, isTelemetryInitialized, setGlobalLogProcessor, setGlobalSpanProcessor, shutdownTelemetry, withTelemetryFlush };

package/dist/instrumentation/hono.cjs

@@ -1,175 +1,7 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_instrumentation_http = require("./http.cjs");
-const require_instrumentation_trust = require("./trust.cjs");
-let _opentelemetry_api = require("@opentelemetry/api");
-let hono_route = require("hono/route");
-//#region src/instrumentation/hono.ts
-const SPAN_KEY = "telemetry.span";
-const CONTEXT_KEY = "telemetry.context";
-/**
-* Get the current span from Hono context
-*/
-function getSpanFromContext(c) {
-	return c.get(SPAN_KEY);
-}
-/**
-* Get the current trace context from Hono context
-*/
-function getTraceContextFromHono(c) {
-	return c.get(CONTEXT_KEY);
-}
-/**
-* Create a telemetry middleware for Hono applications
-*
-* @example
-* ```typescript
-* import { honoTelemetryMiddleware } from '@geekmidas/telescope/instrumentation';
-*
-* const app = new Hono();
-* app.use('*', honoTelemetryMiddleware());
-* ```
-*/
-function honoTelemetryMiddleware(options = {}) {
-	return async (c, next) => {
-		if (options.ignorePaths && shouldIgnorePath(c.req.path, options.ignorePaths)) return next();
-		if (options.shouldSkip?.(c)) return next();
-		const headers = {};
-		c.req.raw.headers.forEach((value, key) => {
-			headers[key] = value;
-		});
-		const { parent: parentContext, links } = require_instrumentation_http.incomingTraceContext(headers, isTrustedCaller(c, options));
-		const attrs = buildHonoSpanAttributes(c, options);
-		const span = require_instrumentation_http.createHttpServerSpan(attrs, parentContext, links);
-		const spanContext = _opentelemetry_api.trace.setSpan(parentContext, span);
-		c.set(SPAN_KEY, span);
-		c.set(CONTEXT_KEY, spanContext);
-		if (options.recordBody) try {
-			const body = await c.req.text();
-			if (body) span.setAttribute("http.request.body", body.length > 4096 ? `${body.slice(0, 4096)}...` : body);
-		} catch {}
-		try {
-			await _opentelemetry_api.context.with(spanContext, async () => {
-				await next();
-			});
-			nameAfterRoute(c, span);
-			const statusCode = c.res.status;
-			if (options.recordResponseBody) try {
-				const body = await c.res.clone().text();
-				if (body) span.setAttribute("http.response.body", body.length > 4096 ? `${body.slice(0, 4096)}...` : body);
-			} catch {}
-			require_instrumentation_http.endHttpSpan(span, { statusCode }, c.error);
-		} catch (error) {
-			nameAfterRoute(c, span);
-			require_instrumentation_http.endHttpSpan(span, { statusCode: 500 }, error instanceof Error ? error : new Error(String(error)));
-			throw error;
-		}
-	};
-}
-/**
-* Whether this request's `traceparent` is continued: from one of the API's
-* own origins, or from an internal caller.
-*/
-function isTrustedCaller(c, options) {
-	const origin = c.req.header("origin");
-	if (origin) {
-		const trusted = typeof options.trustedOrigins === "function" ? options.trustedOrigins() : options.trustedOrigins;
-		return require_instrumentation_trust.isTrustedOrigin(origin, trusted);
-	}
-	const internal = options.internalCallers ?? true;
-	if (typeof internal === "function") return internal(c);
-	if (!internal) return false;
-	return require_instrumentation_trust.isInternalCaller({
-		headers: c.req.raw.headers,
-		remoteAddress: remoteAddressOf(c)
-	});
-}
-/** The TCP peer's address under `@hono/node-server`, or undefined. */
-function remoteAddressOf(c) {
-	return c.env?.incoming?.socket?.remoteAddress;
-}
-/**
-* The route the request matched, once the handler has run — `/users/:id`,
-* never `/users/42` — or undefined when only middleware ran (a 404).
-*
-* Read after `next()`: before it, the route is this middleware's own `*`.
-*/
-function matchedRoute(c) {
-	const path = (0, hono_route.routePath)(c);
-	return path && !path.includes("*") ? path : void 0;
-}
-/** `GET /users/:id`, or the bare method when no route matched. */
-function nameAfterRoute(c, span) {
-	const route = matchedRoute(c);
-	if (route) {
-		span.setAttribute("http.route", route);
-		span.updateName(`${c.req.method} ${route}`);
-	} else span.updateName(c.req.method);
-}
-/**
-* Build span attributes from Hono context
-*/
-function buildHonoSpanAttributes(c, options) {
-	const req = c.req;
-	const url = new URL(req.url);
-	const attrs = {
-		method: req.method,
-		path: url.pathname,
-		host: url.host,
-		scheme: url.protocol.replace(":", ""),
-		userAgent: req.header("user-agent"),
-		clientIp: getClientIp(c),
-		requestId: req.header("x-request-id") || req.header("x-amzn-requestid")
-	};
-	if (options.getUserId) {
-		const userId = options.getUserId(c);
-		if (userId) attrs.user = { userId };
-	}
-	return attrs;
-}
-/**
-* Extract client IP from Hono context
-*/
-function getClientIp(c) {
-	const xForwardedFor = c.req.header("x-forwarded-for");
-	if (xForwardedFor) return xForwardedFor.split(",")[0]?.trim();
-	const xRealIp = c.req.header("x-real-ip");
-	if (xRealIp) return xRealIp;
-	const cfConnectingIp = c.req.header("cf-connecting-ip");
-	if (cfConnectingIp) return cfConnectingIp;
-}
-/**
-* Check if path should be ignored
-*/
-function shouldIgnorePath(path, ignorePaths) {
-	for (const pattern of ignorePaths) if (pattern.endsWith("*")) {
-		const prefix = pattern.slice(0, -1);
-		if (path.startsWith(prefix)) return true;
-	} else if (path === pattern) return true;
-	return false;
-}
-/**
-* 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);
-*   });
-* });
-* ```
-*/
-async function withHonoSpanContext(c, fn) {
-	const ctx = getTraceContextFromHono(c);
-	if (!ctx) return fn();
-	return _opentelemetry_api.context.with(ctx, fn);
-}
-//#endregion
-exports.getSpanFromContext = getSpanFromContext;
-exports.getTraceContextFromHono = getTraceContextFromHono;
-exports.honoTelemetryMiddleware = honoTelemetryMiddleware;
-exports.withHonoSpanContext = withHonoSpanContext;
+require('../http-D_Z8sYXZ.cjs');
+const require_hono = require('../hono-C4EgpbKQ.cjs');
 
-//# sourceMappingURL=hono.cjs.map
+exports.getSpanFromContext = require_hono.getSpanFromContext;
+exports.getTraceContextFromHono = require_hono.getTraceContextFromHono;
+exports.honoTelemetryMiddleware = require_hono.honoTelemetryMiddleware;
+exports.withHonoSpanContext = require_hono.withHonoSpanContext;