@geekmidas/telescope 10.0.0-alpha.99 → 10.0.0

package/dist/instrumentation/hono.d.cts

@@ -1,86 +1,2 @@
-import { Context, MiddlewareHandler } from "hono";
-import { Span } from "@opentelemetry/api";
-//#region src/instrumentation/hono.d.ts
-/**
- * Options for the Hono telemetry middleware
- */
-export 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) => string | undefined;
-  /**
-   * Paths to skip tracing (supports wildcards)
-   */
-  ignorePaths?: string[];
-  /**
-   * Whether to skip tracing for this request
-   */
-  shouldSkip?: (c: Context) => boolean;
-  /**
-   * The origins whose `traceparent` is continued: the API's own sites, the
-   * same list its CORS allows. A request from any other origin starts a new
-   * trace linked to the one it claimed.
-   *
-   * A function is read on each request, for a server that learns its origins
-   * only once the app has loaded its configuration.
-   */
-  trustedOrigins?: readonly string[] | (() => readonly string[] | undefined);
-  /**
-   * Whether a request with no `Origin` from an internal caller continues its
-   * `traceparent` — another service on the private network (see `./trust`):
-   * no `Origin`, no proxy's forwarding header, and a loopback or private
-   * peer address, read from `@hono/node-server`'s socket.
-   *
-   * `false` trusts no caller without an origin; a function decides itself.
-   * @default true
-   */
-  internalCallers?: boolean | ((c: Context) => boolean);
-}
-/**
- * Get the current span from Hono context
- */
-export declare function getSpanFromContext(c: Context): Span | undefined;
-/**
- * Get the current trace context from Hono context
- */
-export declare function getTraceContextFromHono(c: Context): any;
-/**
- * Create a telemetry middleware for Hono applications
- *
- * @example
- * ```typescript
- * import { honoTelemetryMiddleware } from '@geekmidas/telescope/instrumentation';
- *
- * const app = new Hono();
- * app.use('*', honoTelemetryMiddleware());
- * ```
- */
-export 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);
- *   });
- * });
- * ```
- */
-export declare function withHonoSpanContext<T>(c: Context, fn: () => Promise<T>): Promise<T>;
-//#endregion
-//# sourceMappingURL=hono.d.cts.map
+import { HonoTelemetryMiddlewareOptions, getSpanFromContext, getTraceContextFromHono, honoTelemetryMiddleware, withHonoSpanContext } from "../hono-CemCKU87.cjs";
+export { HonoTelemetryMiddlewareOptions, getSpanFromContext, getTraceContextFromHono, honoTelemetryMiddleware, withHonoSpanContext };

package/dist/instrumentation/hono.d.mts

@@ -1,86 +1,2 @@
-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
- */
-export 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;
-  /**
-   * The origins whose `traceparent` is continued: the API's own sites, the
-   * same list its CORS allows. A request from any other origin starts a new
-   * trace linked to the one it claimed.
-   *
-   * A function is read on each request, for a server that learns its origins
-   * only once the app has loaded its configuration.
-   */
-  trustedOrigins?: readonly string[] | (() => readonly string[] | undefined);
-  /**
-   * Whether a request with no `Origin` from an internal caller continues its
-   * `traceparent` — another service on the private network (see `./trust`):
-   * no `Origin`, no proxy's forwarding header, and a loopback or private
-   * peer address, read from `@hono/node-server`'s socket.
-   *
-   * `false` trusts no caller without an origin; a function decides itself.
-   * @default true
-   */
-  internalCallers?: boolean | ((c: Context$1) => boolean);
-}
-/**
- * Get the current span from Hono context
- */
-export declare function getSpanFromContext(c: Context$1): Span | undefined;
-/**
- * Get the current trace context from Hono context
- */
-export 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());
- * ```
- */
-export 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);
- *   });
- * });
- * ```
- */
-export declare function withHonoSpanContext<T>(c: Context$1, fn: () => Promise<T>): Promise<T>;
-//#endregion
-//# sourceMappingURL=hono.d.mts.map
+import { HonoTelemetryMiddlewareOptions, getSpanFromContext, getTraceContextFromHono, honoTelemetryMiddleware, withHonoSpanContext } from "../hono--uKQ7Jgi.mjs";
+export { HonoTelemetryMiddlewareOptions, getSpanFromContext, getTraceContextFromHono, honoTelemetryMiddleware, withHonoSpanContext };

package/dist/instrumentation/hono.mjs

@@ -1,171 +1,4 @@
-import { createHttpServerSpan, endHttpSpan, incomingTraceContext } from "./http.mjs";
-import { isInternalCaller, isTrustedOrigin } from "./trust.mjs";
-import { context, trace } from "@opentelemetry/api";
-import { routePath } from "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 } = incomingTraceContext(headers, isTrustedCaller(c, options));
-		const attrs = buildHonoSpanAttributes(c, options);
-		const span = createHttpServerSpan(attrs, parentContext, links);
-		const spanContext = 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 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 {}
-			endHttpSpan(span, { statusCode }, c.error);
-		} catch (error) {
-			nameAfterRoute(c, span);
-			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 isTrustedOrigin(origin, trusted);
-	}
-	const internal = options.internalCallers ?? true;
-	if (typeof internal === "function") return internal(c);
-	if (!internal) return false;
-	return 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 = 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 context.with(ctx, fn);
-}
-//#endregion
-export { getSpanFromContext, getTraceContextFromHono, honoTelemetryMiddleware, withHonoSpanContext };
+import "../http-DQzgLczm.mjs";
+import { getSpanFromContext, getTraceContextFromHono, honoTelemetryMiddleware, withHonoSpanContext } from "../hono-DxhvnVbF.mjs";
 
-//# sourceMappingURL=hono.mjs.map
+export { getSpanFromContext, getTraceContextFromHono, honoTelemetryMiddleware, withHonoSpanContext };

package/dist/instrumentation/http.cjs

@@ -1,190 +1,12 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let _opentelemetry_api = require("@opentelemetry/api");
-//#region src/instrumentation/http.ts
-const TRACER_NAME = "@geekmidas/constructs";
-/**
-* Get or create a tracer for constructs instrumentation
-*/
-function getConstructsTracer() {
-	return _opentelemetry_api.trace.getTracer(TRACER_NAME);
-}
-/**
-* Convert HTTP attributes to OpenTelemetry semantic conventions
-*/
-function toOtelAttributes(attrs) {
-	const otelAttrs = {};
-	if (attrs.method) otelAttrs["http.request.method"] = attrs.method;
-	if (attrs.url) otelAttrs["url.full"] = attrs.url;
-	if (attrs.path) otelAttrs["url.path"] = attrs.path;
-	if (attrs.route) otelAttrs["http.route"] = attrs.route;
-	if (attrs.host) otelAttrs["server.address"] = attrs.host;
-	if (attrs.scheme) otelAttrs["url.scheme"] = attrs.scheme;
-	if (attrs.userAgent) otelAttrs["user_agent.original"] = attrs.userAgent;
-	if (attrs.clientIp) otelAttrs["client.address"] = attrs.clientIp;
-	if (attrs.requestId) otelAttrs["http.request.id"] = attrs.requestId;
-	if (attrs.response?.statusCode) otelAttrs["http.response.status_code"] = attrs.response.statusCode;
-	if (attrs.response?.responseSize) otelAttrs["http.response.body.size"] = attrs.response.responseSize;
-	if (attrs.endpoint?.name) otelAttrs["endpoint.name"] = attrs.endpoint.name;
-	if (attrs.endpoint?.operationId) otelAttrs["endpoint.operation_id"] = attrs.endpoint.operationId;
-	if (attrs.endpoint?.tags?.length) otelAttrs["endpoint.tags"] = attrs.endpoint.tags;
-	if (attrs.user?.userId) otelAttrs["enduser.id"] = attrs.user.userId;
-	if (attrs.user?.sessionId) otelAttrs["session.id"] = attrs.user.sessionId;
-	if (attrs.user?.roles?.length) otelAttrs["enduser.role"] = attrs.user.roles.join(",");
-	if (attrs.custom) Object.assign(otelAttrs, attrs.custom);
-	return otelAttrs;
-}
-/**
-* Extract trace context from HTTP headers
-*/
-function extractTraceContext(headers) {
-	const normalizedHeaders = {};
-	for (const [key, value] of Object.entries(headers)) if (value) {
-		const stringValue = Array.isArray(value) ? value[0] : value;
-		if (stringValue) normalizedHeaders[key.toLowerCase()] = stringValue;
-	}
-	return _opentelemetry_api.propagation.extract(_opentelemetry_api.context.active(), normalizedHeaders);
-}
-/**
-* The trace a request's span belongs to.
-*
-* From a trusted caller (see `./trust`) its `traceparent` is continued, and
-* the span is its child. From anyone else the span starts a new trace — no
-* parent, no baggage — with a link to the context the caller claimed, so the
-* hop can still be followed without the caller choosing this trace.
-*/
-function incomingTraceContext(headers, trusted) {
-	const extracted = extractTraceContext(headers);
-	if (trusted) return {
-		parent: extracted,
-		links: []
-	};
-	const claimed = _opentelemetry_api.trace.getSpanContext(extracted);
-	return {
-		parent: _opentelemetry_api.trace.deleteSpan(_opentelemetry_api.context.active()),
-		links: claimed && (0, _opentelemetry_api.isSpanContextValid)(claimed) ? [{
-			context: claimed,
-			attributes: { "gkm.trace.untrusted_parent": true }
-		}] : []
-	};
-}
-/**
-* Inject trace context into HTTP headers
-*/
-function injectTraceContext(headers, ctx) {
-	const result = { ...headers };
-	_opentelemetry_api.propagation.inject(ctx ?? _opentelemetry_api.context.active(), result);
-	return result;
-}
-/**
-* Create an HTTP server span for an incoming request
-*/
-function createHttpServerSpan(attrs, parentContext, links) {
-	const tracer = getConstructsTracer();
-	const spanName = attrs.route ? `${attrs.method} ${attrs.route}` : `${attrs.method} ${attrs.path || "/"}`;
-	const ctx = parentContext ?? _opentelemetry_api.context.active();
-	return tracer.startSpan(spanName, {
-		kind: _opentelemetry_api.SpanKind.SERVER,
-		attributes: toOtelAttributes(attrs),
-		...links?.length ? { links } : {}
-	}, ctx);
-}
-/**
-* End an HTTP span with response data
-*/
-function endHttpSpan(span, response, error) {
-	span.setAttribute("http.response.status_code", response.statusCode);
-	if (response.responseSize) span.setAttribute("http.response.body.size", response.responseSize);
-	if (error) {
-		span.recordException(error);
-		span.setStatus({
-			code: _opentelemetry_api.SpanStatusCode.ERROR,
-			message: error.message
-		});
-	} else if (response.statusCode >= 500) span.setStatus({
-		code: _opentelemetry_api.SpanStatusCode.ERROR,
-		message: `HTTP ${response.statusCode}`
-	});
-	else if (response.statusCode < 400) span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
-	span.end();
-}
-/**
-* Execute a function within an HTTP server span context
-*
-* @example
-* ```typescript
-* const result = await withHttpSpan(
-*   { method: 'GET', path: '/users', route: '/users' },
-*   async (span) => {
-*     const users = await getUsers();
-*     return { statusCode: 200, body: users };
-*   }
-* );
-* ```
-*/
-async function withHttpSpan(attrs, fn, parentContext) {
-	const span = createHttpServerSpan(attrs, parentContext);
-	try {
-		const result = await _opentelemetry_api.context.with(_opentelemetry_api.trace.setSpan(parentContext ?? _opentelemetry_api.context.active(), span), () => fn(span));
-		endHttpSpan(span, { statusCode: result.statusCode ?? 200 });
-		return result;
-	} catch (error) {
-		endHttpSpan(span, { statusCode: 500 }, error instanceof Error ? error : new Error(String(error)));
-		throw error;
-	}
-}
-/**
-* Create a child span for internal operations (middleware, handlers, etc.)
-*/
-function createChildSpan(name, attributes) {
-	return getConstructsTracer().startSpan(name, {
-		kind: _opentelemetry_api.SpanKind.INTERNAL,
-		attributes
-	});
-}
-/**
-* Execute a function within a child span
-*/
-async function withChildSpan(name, fn, attributes) {
-	const span = createChildSpan(name, attributes);
-	try {
-		const result = await _opentelemetry_api.context.with(_opentelemetry_api.trace.setSpan(_opentelemetry_api.context.active(), span), () => fn(span));
-		span.setStatus({ code: _opentelemetry_api.SpanStatusCode.OK });
-		return result;
-	} catch (error) {
-		span.setStatus({
-			code: _opentelemetry_api.SpanStatusCode.ERROR,
-			message: error instanceof Error ? error.message : "Unknown error"
-		});
-		span.recordException(error instanceof Error ? error : new Error(String(error)));
-		throw error;
-	} finally {
-		span.end();
-	}
-}
-/**
-* Check if tracing is enabled (OpenTelemetry API is available and configured)
-*/
-function isTracingEnabled() {
-	try {
-		const span = _opentelemetry_api.trace.getTracer(TRACER_NAME).startSpan("test");
-		const isReal = span.spanContext().traceId !== "00000000000000000000000000000000";
-		span.end();
-		return isReal;
-	} catch {
-		return false;
-	}
-}
-//#endregion
-exports.createChildSpan = createChildSpan;
-exports.createHttpServerSpan = createHttpServerSpan;
-exports.endHttpSpan = endHttpSpan;
-exports.extractTraceContext = extractTraceContext;
-exports.getConstructsTracer = getConstructsTracer;
-exports.incomingTraceContext = incomingTraceContext;
-exports.injectTraceContext = injectTraceContext;
-exports.isTracingEnabled = isTracingEnabled;
-exports.toOtelAttributes = toOtelAttributes;
-exports.withChildSpan = withChildSpan;
-exports.withHttpSpan = withHttpSpan;
+const require_http = require('../http-D_Z8sYXZ.cjs');
 
-//# sourceMappingURL=http.cjs.map
+exports.createChildSpan = require_http.createChildSpan;
+exports.createHttpServerSpan = require_http.createHttpServerSpan;
+exports.endHttpSpan = require_http.endHttpSpan;
+exports.extractTraceContext = require_http.extractTraceContext;
+exports.getConstructsTracer = require_http.getConstructsTracer;
+exports.injectTraceContext = require_http.injectTraceContext;
+exports.isTracingEnabled = require_http.isTracingEnabled;
+exports.toOtelAttributes = require_http.toOtelAttributes;
+exports.withChildSpan = require_http.withChildSpan;
+exports.withHttpSpan = require_http.withHttpSpan;

package/dist/instrumentation/http.d.cts

@@ -1,119 +1,2 @@
-import { Attributes, Context, Link, Span } from "@opentelemetry/api";
-//#region src/instrumentation/http.d.ts
-/**
- * HTTP request attributes following OpenTelemetry semantic conventions
- */
-export interface HttpRequestAttributes {
-  method: string;
-  url?: string;
-  path?: string;
-  route?: string;
-  host?: string;
-  scheme?: 'http' | 'https';
-  userAgent?: string;
-  clientIp?: string;
-  requestId?: string;
-}
-/**
- * HTTP response attributes
- */
-export interface HttpResponseAttributes {
-  statusCode: number;
-  responseSize?: number;
-}
-/**
- * Endpoint-specific attributes
- */
-export interface EndpointAttributes {
-  name?: string;
-  operationId?: string;
-  tags?: string[];
-}
-/**
- * User/session attributes
- */
-export interface UserAttributes {
-  userId?: string;
-  sessionId?: string;
-  roles?: string[];
-}
-/**
- * Full span attributes for HTTP requests
- */
-export interface HttpSpanAttributes extends HttpRequestAttributes {
-  response?: HttpResponseAttributes;
-  endpoint?: EndpointAttributes;
-  user?: UserAttributes;
-  custom?: Attributes;
-}
-/**
- * Get or create a tracer for constructs instrumentation
- */
-export declare function getConstructsTracer(): import("@opentelemetry/api").Tracer;
-/**
- * Convert HTTP attributes to OpenTelemetry semantic conventions
- */
-export declare function toOtelAttributes(attrs: HttpSpanAttributes): Attributes;
-/**
- * Extract trace context from HTTP headers
- */
-export declare function extractTraceContext(headers: Record<string, string | string[] | undefined>): Context;
-/** Where a request's span goes: under a parent, or a new root with links. */
-export interface IncomingTraceContext {
-  /** The context the request span starts in. */
-  parent: Context;
-  /** The untrusted caller's context, linked rather than continued. */
-  links: Link[];
-}
-/**
- * The trace a request's span belongs to.
- *
- * From a trusted caller (see `./trust`) its `traceparent` is continued, and
- * the span is its child. From anyone else the span starts a new trace — no
- * parent, no baggage — with a link to the context the caller claimed, so the
- * hop can still be followed without the caller choosing this trace.
- */
-export declare function incomingTraceContext(headers: Record<string, string | string[] | undefined>, trusted: boolean): IncomingTraceContext;
-/**
- * Inject trace context into HTTP headers
- */
-export declare function injectTraceContext(headers: Record<string, string>, ctx?: Context): Record<string, string>;
-/**
- * Create an HTTP server span for an incoming request
- */
-export declare function createHttpServerSpan(attrs: HttpSpanAttributes, parentContext?: Context, links?: Link[]): Span;
-/**
- * End an HTTP span with response data
- */
-export declare function endHttpSpan(span: Span, response: HttpResponseAttributes, error?: Error): void;
-/**
- * Execute a function within an HTTP server span context
- *
- * @example
- * ```typescript
- * const result = await withHttpSpan(
- *   { method: 'GET', path: '/users', route: '/users' },
- *   async (span) => {
- *     const users = await getUsers();
- *     return { statusCode: 200, body: users };
- *   }
- * );
- * ```
- */
-export declare function withHttpSpan<T>(attrs: HttpSpanAttributes, fn: (span: Span) => Promise<T & {
-  statusCode?: number;
-}>, parentContext?: Context): Promise<T>;
-/**
- * Create a child span for internal operations (middleware, handlers, etc.)
- */
-export declare function createChildSpan(name: string, attributes?: Attributes): Span;
-/**
- * Execute a function within a child span
- */
-export declare function withChildSpan<T>(name: string, fn: (span: Span) => Promise<T>, attributes?: Attributes): Promise<T>;
-/**
- * Check if tracing is enabled (OpenTelemetry API is available and configured)
- */
-export declare function isTracingEnabled(): boolean;
-//#endregion
-//# sourceMappingURL=http.d.cts.map
+import { EndpointAttributes, HttpRequestAttributes, HttpResponseAttributes, HttpSpanAttributes, UserAttributes, createChildSpan, createHttpServerSpan, endHttpSpan, extractTraceContext, getConstructsTracer, injectTraceContext, isTracingEnabled, toOtelAttributes, withChildSpan, withHttpSpan } from "../http-Dvca6fC3.cjs";
+export { EndpointAttributes, HttpRequestAttributes, HttpResponseAttributes, HttpSpanAttributes, UserAttributes, createChildSpan, createHttpServerSpan, endHttpSpan, extractTraceContext, getConstructsTracer, injectTraceContext, isTracingEnabled, toOtelAttributes, withChildSpan, withHttpSpan };