@justanalyticsapp/node 0.1.0

package/dist/integrations/express.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * @file packages/node-sdk/src/integrations/express.ts
+ * @description Express middleware for route pattern extraction in JustAnalytics spans.
+ *
+ * Implements Story 036 - HTTP Auto-Instrumentation
+ *
+ * When the HTTP integration creates a server span for an incoming request,
+ * the operation name defaults to `{method} {raw URL}` (e.g., `GET /api/users/42`).
+ * This middleware updates the operation name to use Express route patterns
+ * (e.g., `GET /api/users/:id`) for more meaningful span names.
+ *
+ * The middleware uses `res.on('finish')` to read `req.route` after Express
+ * completes route matching, ensuring it works regardless of middleware ordering.
+ *
+ * Usage:
+ * ```typescript
+ * import JA from '@justanalyticsapp/node';
+ * import express from 'express';
+ *
+ * const app = express();
+ * app.use(JA.expressMiddleware());
+ *
+ * app.get('/api/users/:id', (req, res) => {
+ *   // Span operation name will be updated to "GET /api/users/:id"
+ *   res.json({ id: req.params.id });
+ * });
+ * ```
+ *
+ * References:
+ * - Express routing: req.route is populated after route matching
+ * - Story 035 - Node.js SDK Core (Span class, context module)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressMiddleware = expressMiddleware;
+const context_1 = require("../context");
+/**
+ * Express middleware that extracts `req.route.path` and updates the
+ * active span's operation name to use the route pattern instead
+ * of the raw URL.
+ *
+ * Must be registered via `app.use()` so it runs for all routes.
+ * The route pattern extraction happens in `res.on('finish')`,
+ * which fires after route matching is complete.
+ *
+ * If the SDK is not initialized or no active span exists, the
+ * middleware is a no-op and simply calls `next()`.
+ *
+ * @returns Express-compatible middleware function: `(req, res, next) => void`
+ *
+ * @example
+ * ```typescript
+ * import JA from '@justanalyticsapp/node';
+ * import express from 'express';
+ *
+ * JA.init({ siteId: '...', apiKey: '...', serviceName: 'api' });
+ *
+ * const app = express();
+ * app.use(JA.expressMiddleware());
+ *
+ * app.get('/api/users/:id', handler);
+ * // Span operationName: "GET /api/users/:id" (instead of "GET /api/users/42")
+ * ```
+ */
+function expressMiddleware() {
+    return function jaExpressMiddleware(req, res, next) {
+        // Use res.on('finish') to extract the route after matching
+        res.on('finish', () => {
+            try {
+                const span = (0, context_1.getActiveSpan)();
+                if (!span)
+                    return;
+                const route = req.route?.path;
+                if (route) {
+                    const method = (req.method || 'GET').toUpperCase();
+                    span.updateOperationName(`${method} ${route}`);
+                    span.setAttribute('http.route', route);
+                }
+            }
+            catch {
+                // Never crash the request pipeline
+            }
+        });
+        next();
+    };
+}
+//# sourceMappingURL=express.js.map

package/dist/integrations/express.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.js","sourceRoot":"","sources":["../../src/integrations/express.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;;AAkDH,8CA6BC;AA7ED,wCAA2C;AAoB3C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,SAAgB,iBAAiB;IAK/B,OAAO,SAAS,mBAAmB,CACjC,GAAmB,EACnB,GAAoB,EACpB,IAAyB;QAEzB,2DAA2D;QAC3D,GAAG,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE;YACpB,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,IAAA,uBAAa,GAAE,CAAC;gBAC7B,IAAI,CAAC,IAAI;oBAAE,OAAO;gBAElB,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC;gBAC9B,IAAI,KAAK,EAAE,CAAC;oBACV,MAAM,MAAM,GAAG,CAAC,GAAG,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;oBACnD,IAAI,CAAC,mBAAmB,CAAC,GAAG,MAAM,IAAI,KAAK,EAAE,CAAC,CAAC;oBAC/C,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;gBACzC,CAAC;YACH,CAAC;YAAC,MAAM,CAAC;gBACP,mCAAmC;YACrC,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,EAAE,CAAC;IACT,CAAC,CAAC;AACJ,CAAC"}

package/dist/integrations/http.d.ts

@@ -0,0 +1,129 @@
+/**
+ * @file packages/node-sdk/src/integrations/http.ts
+ * @description HTTP auto-instrumentation integration for the JustAnalytics Node.js SDK.
+ *
+ * Implements Story 036 - HTTP Auto-Instrumentation
+ *
+ * Monkey-patches Node.js built-in `http` and `https` modules to automatically
+ * create spans for incoming and outgoing HTTP traffic. This is the industry-standard
+ * approach used by OpenTelemetry, Datadog dd-trace, and Sentry for Node.js
+ * auto-instrumentation.
+ *
+ * - **Outgoing requests:** Wraps `http.request`, `http.get`, `https.request`,
+ *   `https.get` to create client spans, inject `traceparent` headers, and capture
+ *   response status codes.
+ *
+ * - **Incoming requests:** Patches `http.Server.prototype.emit` to intercept
+ *   the `'request'` event, creating server spans, reading `traceparent` headers,
+ *   and propagating trace context via AsyncLocalStorage.
+ *
+ * References:
+ * - W3C Trace Context specification (traceparent header format)
+ * - OpenTelemetry @opentelemetry/instrumentation-http (similar approach)
+ * - Story 035 - Node.js SDK Core (Span, context, transport)
+ */
+import { Span } from '../span';
+/**
+ * Configuration for the HTTP auto-instrumentation integration.
+ */
+export interface HttpIntegrationOptions {
+    /** Enable/disable the integration (default: true) */
+    enabled?: boolean;
+    /**
+     * URL patterns to exclude from instrumentation.
+     * - string: matched via url.includes(pattern)
+     * - RegExp: matched via pattern.test(url)
+     * Appended to default exclusions unless ignoreDefaults is true.
+     */
+    ignoreUrls?: Array<string | RegExp>;
+    /**
+     * When true, do not apply the default URL exclusion patterns
+     * ('/health', '/ready', '/live', '/favicon.ico', serverUrl).
+     * (default: false)
+     */
+    ignoreDefaults?: boolean;
+    /** Instrument incoming HTTP requests (default: true) */
+    traceIncoming?: boolean;
+    /** Instrument outgoing HTTP requests (default: true) */
+    traceOutgoing?: boolean;
+}
+/**
+ * HttpIntegration monkey-patches http.request/https.request to
+ * auto-create spans for incoming and outgoing HTTP traffic.
+ *
+ * Incoming requests: reads traceparent, creates root server span,
+ * propagates context via AsyncLocalStorage.
+ *
+ * Outgoing requests: injects traceparent header, creates client span
+ * as a child of the active span.
+ */
+export declare class HttpIntegration {
+    private _enabled;
+    private _options;
+    private _serviceName;
+    private _serverUrl;
+    private _onSpanEnd;
+    private _originalHttpRequest;
+    private _originalHttpGet;
+    private _originalHttpsRequest;
+    private _originalHttpsGet;
+    private _originalServerEmit;
+    /**
+     * Create a new HttpIntegration.
+     *
+     * @param serviceName - The service name for span attribution
+     * @param serverUrl - The JustAnalytics server URL (excluded from tracing)
+     * @param options - Integration configuration options
+     * @param onSpanEnd - Callback invoked when a span ends (enqueues to transport)
+     */
+    constructor(serviceName: string, serverUrl: string, options: HttpIntegrationOptions | undefined, onSpanEnd: (span: Span) => void);
+    /**
+     * Activate the integration: patch http/https modules.
+     *
+     * Calling enable() when already enabled is a no-op (idempotent).
+     */
+    enable(): void;
+    /**
+     * Deactivate: restore original http/https functions.
+     *
+     * Calling disable() when not enabled is a no-op (idempotent).
+     */
+    disable(): void;
+    /**
+     * Restore all patched functions to their originals.
+     */
+    private _restoreOriginals;
+    /**
+     * Check if a URL matches any exclusion pattern.
+     *
+     * @param url - The URL string to check
+     * @returns true if the URL should be ignored (not instrumented)
+     */
+    private _shouldIgnore;
+    /**
+     * Wrap an outgoing `http.request` or `https.request` to create client spans.
+     *
+     * @param original - The original request function
+     * @param protocol - 'http' or 'https'
+     * @returns A wrapped version of the request function
+     */
+    private _wrapOutgoingRequest;
+    /**
+     * Wrap an outgoing `http.get` or `https.get` to create client spans.
+     *
+     * `http.get` is like `http.request` but auto-calls `req.end()`.
+     *
+     * @param original - The original get function
+     * @param protocol - 'http' or 'https'
+     * @returns A wrapped version of the get function
+     */
+    private _wrapOutgoingGet;
+    /**
+     * Create a server span for an incoming HTTP request.
+     *
+     * @param req - The incoming HTTP request
+     * @param res - The server response
+     * @returns The created Span, or null if instrumentation should be skipped
+     */
+    private _instrumentIncoming;
+}

package/dist/integrations/http.js

@@ -0,0 +1,465 @@
+"use strict";
+/**
+ * @file packages/node-sdk/src/integrations/http.ts
+ * @description HTTP auto-instrumentation integration for the JustAnalytics Node.js SDK.
+ *
+ * Implements Story 036 - HTTP Auto-Instrumentation
+ *
+ * Monkey-patches Node.js built-in `http` and `https` modules to automatically
+ * create spans for incoming and outgoing HTTP traffic. This is the industry-standard
+ * approach used by OpenTelemetry, Datadog dd-trace, and Sentry for Node.js
+ * auto-instrumentation.
+ *
+ * - **Outgoing requests:** Wraps `http.request`, `http.get`, `https.request`,
+ *   `https.get` to create client spans, inject `traceparent` headers, and capture
+ *   response status codes.
+ *
+ * - **Incoming requests:** Patches `http.Server.prototype.emit` to intercept
+ *   the `'request'` event, creating server spans, reading `traceparent` headers,
+ *   and propagating trace context via AsyncLocalStorage.
+ *
+ * References:
+ * - W3C Trace Context specification (traceparent header format)
+ * - OpenTelemetry @opentelemetry/instrumentation-http (similar approach)
+ * - Story 035 - Node.js SDK Core (Span, context, transport)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpIntegration = void 0;
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const url_1 = require("url");
+const span_1 = require("../span");
+const headers_1 = require("../utils/headers");
+const context_1 = require("../context");
+const id_1 = require("../utils/id");
+/** Default URL patterns to exclude from instrumentation */
+const DEFAULT_IGNORE_URLS = [
+    '/health',
+    '/ready',
+    '/live',
+    '/favicon.ico',
+];
+/**
+ * Escape special RegExp characters in a string.
+ *
+ * @param str - String to escape
+ * @returns Escaped string safe for use in a RegExp
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Normalize the various overloaded argument forms of http.request / http.get
+ * into a consistent { url, options, callback } shape.
+ *
+ * Node.js supports three call signatures:
+ * - request(url: string | URL, options?, callback?)
+ * - request(options, callback?)
+ *
+ * @param args - The arguments passed to http.request / http.get
+ * @param protocol - 'http' or 'https' for URL construction
+ * @returns Normalized { urlString, options, callback }
+ */
+function normalizeRequestArgs(args, protocol) {
+    let urlString;
+    let options;
+    let callback;
+    if (typeof args[0] === 'string' || args[0] instanceof url_1.URL) {
+        // request(url, options?, callback?)
+        const urlArg = args[0] instanceof url_1.URL ? args[0] : new url_1.URL(args[0]);
+        urlString = urlArg.toString();
+        if (typeof args[1] === 'function') {
+            options = {};
+            callback = args[1];
+        }
+        else if (typeof args[1] === 'object' && args[1] !== null) {
+            options = args[1];
+            callback = typeof args[2] === 'function'
+                ? args[2]
+                : undefined;
+        }
+        else {
+            options = {};
+            callback = undefined;
+        }
+        // Merge URL into options if not already set
+        if (!options.hostname && !options.host) {
+            options.hostname = urlArg.hostname;
+            options.port = urlArg.port || undefined;
+            options.path = urlArg.pathname + urlArg.search;
+            options.protocol = urlArg.protocol;
+        }
+    }
+    else if (typeof args[0] === 'object' && args[0] !== null) {
+        // request(options, callback?)
+        options = args[0];
+        callback = typeof args[1] === 'function'
+            ? args[1]
+            : undefined;
+        // Build URL string from options
+        const hostname = options.hostname || options.host || 'localhost';
+        const cleanHost = hostname.replace(/:\d+$/, '');
+        const port = options.port;
+        const path = options.path || '/';
+        const proto = options.protocol || `${protocol}:`;
+        const defaultPort = proto === 'https:' ? 443 : 80;
+        const portStr = port && Number(port) !== defaultPort ? `:${port}` : '';
+        urlString = `${proto}//${cleanHost}${portStr}${path}`;
+    }
+    else {
+        // Fallback: unknown call pattern
+        options = {};
+        callback = undefined;
+        urlString = `${protocol}://unknown/`;
+    }
+    return { urlString, options, callback };
+}
+/**
+ * HttpIntegration monkey-patches http.request/https.request to
+ * auto-create spans for incoming and outgoing HTTP traffic.
+ *
+ * Incoming requests: reads traceparent, creates root server span,
+ * propagates context via AsyncLocalStorage.
+ *
+ * Outgoing requests: injects traceparent header, creates client span
+ * as a child of the active span.
+ */
+class HttpIntegration {
+    /**
+     * Create a new HttpIntegration.
+     *
+     * @param serviceName - The service name for span attribution
+     * @param serverUrl - The JustAnalytics server URL (excluded from tracing)
+     * @param options - Integration configuration options
+     * @param onSpanEnd - Callback invoked when a span ends (enqueues to transport)
+     */
+    constructor(serviceName, serverUrl, options, onSpanEnd) {
+        this._enabled = false;
+        // Store original functions for restoration
+        this._originalHttpRequest = null;
+        this._originalHttpGet = null;
+        this._originalHttpsRequest = null;
+        this._originalHttpsGet = null;
+        this._originalServerEmit = null;
+        this._serviceName = serviceName;
+        this._serverUrl = serverUrl;
+        this._onSpanEnd = onSpanEnd;
+        // Resolve options with defaults
+        const opts = options || {};
+        const ignoreDefaults = opts.ignoreDefaults === true;
+        const customIgnoreUrls = opts.ignoreUrls || [];
+        // Build the combined ignore list
+        let ignoreUrls;
+        if (ignoreDefaults) {
+            ignoreUrls = [...customIgnoreUrls];
+        }
+        else {
+            // Build server URL exclusion pattern
+            const serverUrlPatterns = [];
+            try {
+                const parsed = new url_1.URL(serverUrl);
+                serverUrlPatterns.push(new RegExp(`^https?://${escapeRegex(parsed.host)}`));
+            }
+            catch {
+                // If serverUrl is malformed, skip it
+            }
+            ignoreUrls = [...DEFAULT_IGNORE_URLS, ...serverUrlPatterns, ...customIgnoreUrls];
+        }
+        this._options = {
+            enabled: opts.enabled !== false,
+            ignoreUrls,
+            ignoreDefaults,
+            traceIncoming: opts.traceIncoming !== false,
+            traceOutgoing: opts.traceOutgoing !== false,
+        };
+    }
+    /**
+     * Activate the integration: patch http/https modules.
+     *
+     * Calling enable() when already enabled is a no-op (idempotent).
+     */
+    enable() {
+        if (this._enabled)
+            return;
+        if (!this._options.enabled)
+            return;
+        try {
+            // Patch outgoing requests
+            if (this._options.traceOutgoing) {
+                this._originalHttpRequest = http_1.default.request;
+                this._originalHttpGet = http_1.default.get;
+                this._originalHttpsRequest = https_1.default.request;
+                this._originalHttpsGet = https_1.default.get;
+                http_1.default.request = this._wrapOutgoingRequest(this._originalHttpRequest, 'http');
+                http_1.default.get = this._wrapOutgoingGet(this._originalHttpGet, 'http');
+                https_1.default.request = this._wrapOutgoingRequest(this._originalHttpsRequest, 'https');
+                https_1.default.get = this._wrapOutgoingGet(this._originalHttpsGet, 'https');
+            }
+            // Patch incoming requests via http.Server.prototype.emit
+            if (this._options.traceIncoming) {
+                this._originalServerEmit = http_1.default.Server.prototype.emit;
+                const integration = this;
+                const originalEmit = this._originalServerEmit;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                http_1.default.Server.prototype.emit = function patchedEmit(event, ...args) {
+                    if (event === 'request') {
+                        const req = args[0];
+                        const res = args[1];
+                        const urlString = req.url || '/';
+                        // Check exclusion
+                        if (!integration._shouldIgnore(urlString)) {
+                            const span = integration._instrumentIncoming(req, res);
+                            if (span) {
+                                // Run the rest of the request pipeline in span context
+                                const childContext = (0, context_1.createChildContext)({
+                                    activeSpan: span,
+                                    traceId: span.traceId,
+                                });
+                                return (0, context_1.runWithContext)(childContext, () => {
+                                    return originalEmit.apply(this, [event, ...args]);
+                                });
+                            }
+                        }
+                    }
+                    return originalEmit.apply(this, [event, ...args]);
+                };
+            }
+            this._enabled = true;
+        }
+        catch (error) {
+            // Monkey-patching failed; fall back to no-op
+            this._restoreOriginals();
+            if (typeof console !== 'undefined') {
+                console.warn('[JustAnalytics] Failed to enable HTTP integration:', error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    /**
+     * Deactivate: restore original http/https functions.
+     *
+     * Calling disable() when not enabled is a no-op (idempotent).
+     */
+    disable() {
+        if (!this._enabled)
+            return;
+        this._restoreOriginals();
+        this._enabled = false;
+    }
+    /**
+     * Restore all patched functions to their originals.
+     */
+    _restoreOriginals() {
+        if (this._originalHttpRequest) {
+            http_1.default.request = this._originalHttpRequest;
+            this._originalHttpRequest = null;
+        }
+        if (this._originalHttpGet) {
+            http_1.default.get = this._originalHttpGet;
+            this._originalHttpGet = null;
+        }
+        if (this._originalHttpsRequest) {
+            https_1.default.request = this._originalHttpsRequest;
+            this._originalHttpsRequest = null;
+        }
+        if (this._originalHttpsGet) {
+            https_1.default.get = this._originalHttpsGet;
+            this._originalHttpsGet = null;
+        }
+        if (this._originalServerEmit) {
+            http_1.default.Server.prototype.emit = this._originalServerEmit;
+            this._originalServerEmit = null;
+        }
+    }
+    /**
+     * Check if a URL matches any exclusion pattern.
+     *
+     * @param url - The URL string to check
+     * @returns true if the URL should be ignored (not instrumented)
+     */
+    _shouldIgnore(url) {
+        for (const pattern of this._options.ignoreUrls) {
+            if (typeof pattern === 'string') {
+                if (url.includes(pattern))
+                    return true;
+            }
+            else if (pattern instanceof RegExp) {
+                if (pattern.test(url))
+                    return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Wrap an outgoing `http.request` or `https.request` to create client spans.
+     *
+     * @param original - The original request function
+     * @param protocol - 'http' or 'https'
+     * @returns A wrapped version of the request function
+     */
+    _wrapOutgoingRequest(original, protocol) {
+        const integration = this;
+        return function patchedRequest(...args) {
+            try {
+                const { urlString, options, callback } = normalizeRequestArgs(args, protocol);
+                // Check if URL should be ignored
+                if (integration._shouldIgnore(urlString)) {
+                    return original.apply(this, args);
+                }
+                // Get active span context
+                const parentSpan = (0, context_1.getActiveSpan)();
+                const traceId = parentSpan?.traceId ?? (0, id_1.generateTraceId)();
+                const parentSpanId = parentSpan?.id ?? null;
+                const method = (options.method || 'GET').toUpperCase();
+                const hostname = options.hostname || options.host || 'unknown';
+                const cleanHostname = hostname.replace(/:\d+$/, '');
+                const path = options.path || '/';
+                // Create client span
+                const span = new span_1.Span({
+                    operationName: `${method} ${cleanHostname}${path}`,
+                    serviceName: integration._serviceName,
+                    kind: 'client',
+                    traceId,
+                    parentSpanId,
+                    attributes: {
+                        'http.method': method,
+                        'http.url': urlString,
+                        'http.host': cleanHostname,
+                    },
+                });
+                // Inject traceparent header
+                if (!options.headers || Array.isArray(options.headers)) {
+                    options.headers = {};
+                }
+                options.headers['traceparent'] = (0, headers_1.serializeTraceparent)(span.traceId, span.id);
+                // Build new args with modified options
+                // We always call original(options, wrappedCallback) to ensure headers are applied
+                const wrappedCallback = (res) => {
+                    const statusCode = res.statusCode || 0;
+                    span.setAttribute('http.status_code', statusCode);
+                    if (statusCode >= 400) {
+                        span.setStatus('error', `HTTP ${statusCode}`);
+                    }
+                    span.end();
+                    integration._onSpanEnd(span);
+                    if (callback) {
+                        callback(res);
+                    }
+                };
+                let req;
+                try {
+                    req = original.call(this, options, wrappedCallback);
+                }
+                catch (err) {
+                    // If the original call throws, end span with error
+                    span.setStatus('error', err instanceof Error ? err.message : String(err));
+                    span.end();
+                    integration._onSpanEnd(span);
+                    throw err;
+                }
+                req.on('error', (err) => {
+                    if (!span.isEnded) {
+                        span.setStatus('error', err.message);
+                        span.end();
+                        integration._onSpanEnd(span);
+                    }
+                });
+                return req;
+            }
+            catch (error) {
+                // If our instrumentation code fails, fall through to original
+                return original.apply(this, args);
+            }
+        };
+    }
+    /**
+     * Wrap an outgoing `http.get` or `https.get` to create client spans.
+     *
+     * `http.get` is like `http.request` but auto-calls `req.end()`.
+     *
+     * @param original - The original get function
+     * @param protocol - 'http' or 'https'
+     * @returns A wrapped version of the get function
+     */
+    _wrapOutgoingGet(original, protocol) {
+        const integration = this;
+        // Use the already-patched request for get
+        const patchedRequest = this._wrapOutgoingRequest(protocol === 'http' ? (this._originalHttpRequest || http_1.default.request) : (this._originalHttpsRequest || https_1.default.request), protocol);
+        return function patchedGet(...args) {
+            const req = patchedRequest.apply(this, args);
+            req.end();
+            return req;
+        };
+    }
+    /**
+     * Create a server span for an incoming HTTP request.
+     *
+     * @param req - The incoming HTTP request
+     * @param res - The server response
+     * @returns The created Span, or null if instrumentation should be skipped
+     */
+    _instrumentIncoming(req, res) {
+        try {
+            const urlString = req.url || '/';
+            const method = (req.method || 'GET').toUpperCase();
+            // Parse traceparent from incoming headers
+            const traceparentHeader = req.headers['traceparent'];
+            let traceId;
+            let parentSpanId;
+            if (traceparentHeader) {
+                const parsed = (0, headers_1.parseTraceparent)(traceparentHeader);
+                if (parsed) {
+                    traceId = parsed.traceId;
+                    parentSpanId = parsed.parentSpanId;
+                }
+                else {
+                    // Invalid traceparent -- generate new trace
+                    traceId = (0, id_1.generateTraceId)();
+                    parentSpanId = null;
+                }
+            }
+            else {
+                traceId = (0, id_1.generateTraceId)();
+                parentSpanId = null;
+            }
+            // Create server span
+            const span = new span_1.Span({
+                operationName: `${method} ${urlString}`,
+                serviceName: this._serviceName,
+                kind: 'server',
+                traceId,
+                parentSpanId,
+                attributes: {
+                    'http.method': method,
+                    'http.url': urlString,
+                    'http.host': req.headers.host || 'unknown',
+                    'http.user_agent': req.headers['user-agent'] || '',
+                },
+            });
+            const integration = this;
+            // End span when response finishes
+            res.on('finish', () => {
+                try {
+                    span.setAttribute('http.status_code', res.statusCode);
+                    if (res.statusCode >= 500) {
+                        span.setStatus('error', `HTTP ${res.statusCode}`);
+                    }
+                    span.end();
+                    integration._onSpanEnd(span);
+                }
+                catch {
+                    // Never crash the request pipeline
+                }
+            });
+            return span;
+        }
+        catch {
+            // Instrumentation failure -- do not crash
+            return null;
+        }
+    }
+}
+exports.HttpIntegration = HttpIntegration;
+//# sourceMappingURL=http.js.map