@opentelemetry/instrumentation-http 0.219.0 → 0.221.0

package/README.md

@@ -7,9 +7,6 @@
 
 This module provides automatic instrumentation for [`http`](https://nodejs.org/api/http.html) and [`https`](https://nodejs.org/api/https.html).
 
-For automatic instrumentation see the
-[@opentelemetry/sdk-trace-node](https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/opentelemetry-sdk-trace-node) package.
-
 ## Installation
 
 ```bash
@@ -27,24 +24,23 @@ OpenTelemetry HTTP Instrumentation allows the user to automatically collect tele
 To load a specific instrumentation (HTTP in this case), specify it in the Node Tracer's configuration.
 
 ```js
+const { trace } = require('@opentelemetry/api');
 const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http');
-const {
-  ConsoleSpanExporter,
-  NodeTracerProvider,
-  SimpleSpanProcessor,
-} = require('@opentelemetry/sdk-trace-node');
+const { ConsoleSpanExporter, TracerProvider, SimpleSpanProcessor } = require('@opentelemetry/sdk-trace');
 const { registerInstrumentations } = require('@opentelemetry/instrumentation');
 
-const provider = new NodeTracerProvider({
-  spanProcessors: [new SimpleSpanProcessor(new ConsoleSpanExporter())]
+const tracerProvider = new TracerProvider({
+  spanProcessors: [
+    new SimpleSpanProcessor({ exporter: new ConsoleSpanExporter() })
+  ]
 });
-
-provider.register();
+trace.setGlobalTracerProvider(tracerProvider);
+// See https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/sdk-trace/
+// for a more complete example setting up a *context manager* and *propagators*.
 
 registerInstrumentations({
   instrumentations: [new HttpInstrumentation()],
 });
-
 ```
 
 See [examples/http](https://github.com/open-telemetry/opentelemetry-js/tree/main/examples/http) for a short example.
@@ -65,7 +61,7 @@ Options                                 | Type
 `ignoreOutgoingRequestHook`             | `IgnoreOutgoingRequestFunction`            | Function for filtering outgoing requests. HTTP instrumentation will not trace outgoing requests for which the function returns `true`.
 `disableOutgoingRequestInstrumentation` | `boolean`                                  | Set to true to avoid instrumenting outgoing requests at all. This can be helpful when another instrumentation handles outgoing requests.
 `disableIncomingRequestInstrumentation` | `boolean`                                  | Set to true to avoid instrumenting incoming requests at all. This can be helpful when another instrumentation handles incoming requests.
-`serverName`                            | `string`                                   | The primary server name of the matched virtual host.
+`serverName`                            | `string`                                   | **Deprecated.** No longer used. Stable HTTP semantic conventions do not include the `http.server_name` attribute; this option has no effect.
 `requireParentforOutgoingSpans`         | Boolean                                    | Require that is a parent span to create new span for outgoing requests.
 `requireParentforIncomingSpans`         | Boolean                                    | Require that is a parent span to create new span for incoming requests.
 `headersToSpanAttributes`               | `object`                                   | Specify which HTTP headers should be captured as span attributes. This is an object of the form `{client: {requestHeaders: [...], responseHeaders: [...]}, server: {requestHeaders: [...], responseHeaders: [...]}}`, where each `[...]` is an array of HTTP header names (case-insensitive) to capture. Client (outgoing requests, incoming responses) and server (incoming requests, outgoing responses) headers will be converted to span attributes in the form of `http.{request,response}.header.$header_name`, e.g. `http.response.header.content_length`. By default hyphens in header names are converted to underscore. However, if stable semantic conventions are selected (see next section), then, hyphens in header names are not changed, e.g. `http.response.header.content-length`.
@@ -87,7 +83,7 @@ Hook type                                  | Parameters
 Prior to version `0.54.0`, this instrumentation created spans targeting an experimental semantic convention [Version 1.7.0](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.7.0/semantic_conventions/README.md).
 
 HTTP semantic conventions (semconv) were stabilized in v1.23.0, and a [migration process](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/non-normative/http-migration.md#http-semantic-convention-stability-migration) was defined.
-`instrumentation-http` versions 0.54.0 and later include support for migrating to stable HTTP semantic conventions, as described below.
+`instrumentation-http` versions 0.54.0 - XXXX include support for migrating to stable HTTP semantic conventions, as described below.
 The intent is to provide an approximate 6 month time window for users of this instrumentation to migrate to the new HTTP semconv, after which a new minor version will use the *new* semconv by default and drop support for the old semconv.
 See the [HTTP semconv migration plan for OpenTelemetry JS instrumentations](https://github.com/open-telemetry/opentelemetry-js/issues/5646).
 
@@ -97,6 +93,8 @@ To select which semconv version(s) is emitted from this instrumentation, use the
 - `http/dup`: emit **both** the old v1.7.0 and the new (stable) v1.23.0+ semantics
 - By default, if `OTEL_SEMCONV_STABILITY_OPT_IN` includes neither of the above tokens, the old v1.7.0 semconv is used.
 
+`instrumentation-http` versions XXX and later emit the stable v1.23.0+ semantics only.
+
 ### Attributes collected
 
 v1.7.0 semconv                              | v1.23.0 semconv                     | Short Description

package/build/src/http.d.ts

@@ -9,11 +9,8 @@ export declare class HttpInstrumentation extends InstrumentationBase<HttpInstrum
     private _headerCapture;
     private _httpPatched;
     private _httpsPatched;
-    private _oldHttpServerDurationHistogram;
-    private _stableHttpServerDurationHistogram;
-    private _oldHttpClientDurationHistogram;
-    private _stableHttpClientDurationHistogram;
-    private _semconvStability;
+    private _httpServerDurationHistogram;
+    private _httpClientDurationHistogram;
     constructor(config?: HttpInstrumentationConfig);
     protected _updateMetricInstruments(): void;
     private _recordServerDuration;
@@ -46,8 +43,7 @@ export declare class HttpInstrumentation extends InstrumentationBase<HttpInstrum
      * @param request The original request object.
      * @param span representing the current operation
      * @param startTime representing the start time of the request to calculate duration in Metric
-     * @param oldMetricAttributes metric attributes for old semantic conventions
-     * @param stableMetricAttributes metric attributes for new semantic conventions
+     * @param metricAttributes metric attributes for the request duration metric
      */
     private _traceClientRequest;
     private _incomingRequestFunction;

package/build/src/http.js

@@ -22,24 +22,12 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
     _headerCapture;
     _httpPatched = false;
     _httpsPatched = false;
-    _semconvStability = instrumentation_1.SemconvStability.OLD;
     constructor(config = {}) {
         super('@opentelemetry/instrumentation-http', version_1.VERSION, config);
-        this._semconvStability = (0, instrumentation_1.semconvStabilityFromStr)('http', process.env.OTEL_SEMCONV_STABILITY_OPT_IN);
-        this._headerCapture = this._createHeaderCapture(this._semconvStability);
+        this._headerCapture = this._createHeaderCapture();
     }
     _updateMetricInstruments() {
-        this._oldHttpServerDurationHistogram = this.meter.createHistogram('http.server.duration', {
-            description: 'Measures the duration of inbound HTTP requests.',
-            unit: 'ms',
-            valueType: api_1.ValueType.DOUBLE,
-        });
-        this._oldHttpClientDurationHistogram = this.meter.createHistogram('http.client.duration', {
-            description: 'Measures the duration of outbound HTTP requests.',
-            unit: 'ms',
-            valueType: api_1.ValueType.DOUBLE,
-        });
-        this._stableHttpServerDurationHistogram = this.meter.createHistogram(semantic_conventions_1.METRIC_HTTP_SERVER_REQUEST_DURATION, {
+        this._httpServerDurationHistogram = this.meter.createHistogram(semantic_conventions_1.METRIC_HTTP_SERVER_REQUEST_DURATION, {
             description: 'Duration of HTTP server requests.',
             unit: 's',
             valueType: api_1.ValueType.DOUBLE,
@@ -50,7 +38,7 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                 ],
             },
         });
-        this._stableHttpClientDurationHistogram = this.meter.createHistogram(semantic_conventions_1.METRIC_HTTP_CLIENT_REQUEST_DURATION, {
+        this._httpClientDurationHistogram = this.meter.createHistogram(semantic_conventions_1.METRIC_HTTP_CLIENT_REQUEST_DURATION, {
             description: 'Duration of HTTP client requests.',
             unit: 's',
             valueType: api_1.ValueType.DOUBLE,
@@ -62,29 +50,17 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
             },
         });
     }
-    _recordServerDuration(durationMs, oldAttributes, stableAttributes) {
-        if (this._semconvStability & instrumentation_1.SemconvStability.OLD) {
-            // old histogram is counted in MS
-            this._oldHttpServerDurationHistogram.record(durationMs, oldAttributes);
-        }
-        if (this._semconvStability & instrumentation_1.SemconvStability.STABLE) {
-            // stable histogram is counted in S
-            this._stableHttpServerDurationHistogram.record(durationMs / 1000, stableAttributes);
-        }
+    _recordServerDuration(durationMs, attributes) {
+        // stable histogram is counted in S
+        this._httpServerDurationHistogram.record(durationMs / 1000, attributes);
     }
-    _recordClientDuration(durationMs, oldAttributes, stableAttributes) {
-        if (this._semconvStability & instrumentation_1.SemconvStability.OLD) {
-            // old histogram is counted in MS
-            this._oldHttpClientDurationHistogram.record(durationMs, oldAttributes);
-        }
-        if (this._semconvStability & instrumentation_1.SemconvStability.STABLE) {
-            // stable histogram is counted in S
-            this._stableHttpClientDurationHistogram.record(durationMs / 1000, stableAttributes);
-        }
+    _recordClientDuration(durationMs, attributes) {
+        // stable histogram is counted in S
+        this._httpClientDurationHistogram.record(durationMs / 1000, attributes);
     }
     setConfig(config = {}) {
         super.setConfig(config);
-        this._headerCapture = this._createHeaderCapture(this._semconvStability);
+        this._headerCapture = this._createHeaderCapture();
     }
     init() {
         return [this._getHttpsInstrumentation(), this._getHttpInstrumentation()];
@@ -238,10 +214,9 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
      * @param request The original request object.
      * @param span representing the current operation
      * @param startTime representing the start time of the request to calculate duration in Metric
-     * @param oldMetricAttributes metric attributes for old semantic conventions
-     * @param stableMetricAttributes metric attributes for new semantic conventions
+     * @param metricAttributes metric attributes for the request duration metric
      */
-    _traceClientRequest(request, span, startTime, oldMetricAttributes, stableMetricAttributes) {
+    _traceClientRequest(request, span, startTime, metricAttributes) {
         if (this.getConfig().requestHook) {
             this._callRequestHook(span, request);
         }
@@ -259,10 +234,9 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
             if (request.listenerCount('response') <= 1) {
                 response.resume();
             }
-            const responseAttributes = (0, utils_1.getOutgoingRequestAttributesOnResponse)(response, this._semconvStability);
+            const responseAttributes = (0, utils_1.getOutgoingRequestAttributesOnResponse)(response);
             span.setAttributes(responseAttributes);
-            oldMetricAttributes = Object.assign(oldMetricAttributes, (0, utils_1.getOutgoingRequestMetricAttributesOnResponse)(responseAttributes));
-            stableMetricAttributes = Object.assign(stableMetricAttributes, (0, utils_1.getOutgoingStableRequestMetricAttributesOnResponse)(responseAttributes));
+            metricAttributes = Object.assign(metricAttributes, (0, utils_1.getOutgoingStableRequestMetricAttributesOnResponse)(responseAttributes));
             if (this.getConfig().responseHook) {
                 this._callResponseHook(span, response);
             }
@@ -289,7 +263,7 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                 if (this.getConfig().applyCustomAttributesOnSpan) {
                     (0, instrumentation_1.safeExecuteInTheMiddle)(() => this.getConfig().applyCustomAttributesOnSpan(span, request, response), () => { }, true);
                 }
-                this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, oldMetricAttributes, stableMetricAttributes);
+                this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, metricAttributes);
             };
             response.on('end', endHandler);
             response.on(events_1.errorMonitor, (error) => {
@@ -298,7 +272,7 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                     return;
                 }
                 responseFinished = true;
-                this._onOutgoingRequestError(span, oldMetricAttributes, stableMetricAttributes, startTime, error);
+                this._onOutgoingRequestError(span, metricAttributes, startTime, error);
             });
         });
         request.on('close', () => {
@@ -307,7 +281,7 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                 return;
             }
             responseFinished = true;
-            this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, oldMetricAttributes, stableMetricAttributes);
+            this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, metricAttributes);
         });
         request.on(events_1.errorMonitor, (error) => {
             this._diag.debug('outgoingRequest on request error()', error);
@@ -315,7 +289,7 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                 return;
             }
             responseFinished = true;
-            this._onOutgoingRequestError(span, oldMetricAttributes, stableMetricAttributes, startTime, error);
+            this._onOutgoingRequestError(span, metricAttributes, startTime, error);
         });
         this._diag.debug('http.ClientRequest return request');
         return request;
@@ -345,9 +319,7 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
             const headers = request.headers;
             const spanAttributes = (0, utils_1.getIncomingRequestAttributes)(request, {
                 component: component,
-                serverName: instrumentation.getConfig().serverName,
                 hookAttributes: instrumentation._callStartSpanHook(request, instrumentation.getConfig().startIncomingSpanHook),
-                semconvStability: instrumentation._semconvStability,
                 enableSyntheticSourceDetection: instrumentation.getConfig().enableSyntheticSourceDetection || false,
             }, instrumentation._diag);
             Object.assign(spanAttributes, instrumentation._headerCapture.server.captureRequestHeaders(header => request.headers[header]));
@@ -356,15 +328,14 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                 attributes: spanAttributes,
             };
             const startTime = (0, core_1.hrTime)();
-            const oldMetricAttributes = (0, utils_1.getIncomingRequestMetricAttributes)(spanAttributes);
             // request method and url.scheme are both required span attributes
-            const stableMetricAttributes = {
+            const metricAttributes = {
                 [semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD]: spanAttributes[semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD],
                 [semantic_conventions_1.ATTR_URL_SCHEME]: spanAttributes[semantic_conventions_1.ATTR_URL_SCHEME],
             };
             // recommended if and only if one was sent, same as span recommendation
             if (spanAttributes[semantic_conventions_1.ATTR_NETWORK_PROTOCOL_VERSION]) {
-                stableMetricAttributes[semantic_conventions_1.ATTR_NETWORK_PROTOCOL_VERSION] =
+                metricAttributes[semantic_conventions_1.ATTR_NETWORK_PROTOCOL_VERSION] =
                     spanAttributes[semantic_conventions_1.ATTR_NETWORK_PROTOCOL_VERSION];
             }
             const ctx = api_1.propagation.extract(api_1.ROOT_CONTEXT, headers);
@@ -388,15 +359,15 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                     if (hasError) {
                         return;
                     }
-                    instrumentation._onServerResponseFinish(request, response, span, oldMetricAttributes, stableMetricAttributes, startTime);
+                    instrumentation._onServerResponseFinish(request, response, span, metricAttributes, startTime);
                 });
                 response.on(events_1.errorMonitor, (err) => {
                     hasError = true;
-                    instrumentation._onServerResponseError(span, oldMetricAttributes, stableMetricAttributes, startTime, err);
+                    instrumentation._onServerResponseError(span, metricAttributes, startTime, err);
                 });
                 return (0, instrumentation_1.safeExecuteInTheMiddle)(() => original.apply(this, [event, ...args]), error => {
                     if (error) {
-                        instrumentation._onServerResponseError(span, oldMetricAttributes, stableMetricAttributes, startTime, error);
+                        instrumentation._onServerResponseError(span, metricAttributes, startTime, error);
                         throw error;
                     }
                 });
@@ -430,23 +401,22 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                 hostname,
                 hookAttributes: instrumentation._callStartSpanHook(optionsParsed, instrumentation.getConfig().startOutgoingSpanHook),
                 redactedQueryParams: instrumentation.getConfig().redactedQueryParams, // Added config for adding custom query strings
-            }, instrumentation._semconvStability, instrumentation.getConfig().enableSyntheticSourceDetection || false);
+            }, instrumentation.getConfig().enableSyntheticSourceDetection || false);
             const startTime = (0, core_1.hrTime)();
-            const oldMetricAttributes = (0, utils_1.getOutgoingRequestMetricAttributes)(attributes);
             // request method, server address, and server port are both required span attributes
-            const stableMetricAttributes = {
+            const metricAttributes = {
                 [semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD]: attributes[semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD],
                 [semantic_conventions_1.ATTR_SERVER_ADDRESS]: attributes[semantic_conventions_1.ATTR_SERVER_ADDRESS],
                 [semantic_conventions_1.ATTR_SERVER_PORT]: attributes[semantic_conventions_1.ATTR_SERVER_PORT],
             };
             // required if and only if one was sent, same as span requirement
             if (attributes[semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE]) {
-                stableMetricAttributes[semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE] =
+                metricAttributes[semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE] =
                     attributes[semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE];
             }
             // recommended if and only if one was sent, same as span recommendation
             if (attributes[semantic_conventions_1.ATTR_NETWORK_PROTOCOL_VERSION]) {
-                stableMetricAttributes[semantic_conventions_1.ATTR_NETWORK_PROTOCOL_VERSION] =
+                metricAttributes[semantic_conventions_1.ATTR_NETWORK_PROTOCOL_VERSION] =
                     attributes[semantic_conventions_1.ATTR_NETWORK_PROTOCOL_VERSION];
             }
             const spanOptions = {
@@ -486,20 +456,19 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                     }
                 }, error => {
                     if (error) {
-                        instrumentation._onOutgoingRequestError(span, oldMetricAttributes, stableMetricAttributes, startTime, error);
+                        instrumentation._onOutgoingRequestError(span, metricAttributes, startTime, error);
                         throw error;
                     }
                 });
                 instrumentation._diag.debug(`${component} instrumentation outgoingRequest`);
                 api_1.context.bind(parentContext, request);
-                return instrumentation._traceClientRequest(request, span, startTime, oldMetricAttributes, stableMetricAttributes);
+                return instrumentation._traceClientRequest(request, span, startTime, metricAttributes);
             });
         };
     }
-    _onServerResponseFinish(request, response, span, oldMetricAttributes, stableMetricAttributes, startTime) {
-        const attributes = (0, utils_1.getIncomingRequestAttributesOnResponse)(request, response, this._semconvStability);
-        oldMetricAttributes = Object.assign(oldMetricAttributes, (0, utils_1.getIncomingRequestMetricAttributesOnResponse)(attributes));
-        stableMetricAttributes = Object.assign(stableMetricAttributes, (0, utils_1.getIncomingStableRequestMetricAttributesOnResponse)(attributes));
+    _onServerResponseFinish(request, response, span, metricAttributes, startTime) {
+        const attributes = (0, utils_1.getIncomingRequestAttributesOnResponse)(response);
+        metricAttributes = Object.assign(metricAttributes, (0, utils_1.getIncomingStableRequestMetricAttributesOnResponse)(attributes));
         span.setAttributes(this._headerCapture.server.captureResponseHeaders(header => response.getHeader(header)));
         span.setAttributes(attributes).setStatus({
             code: (0, utils_1.parseResponseStatus)(api_1.SpanKind.SERVER, response.statusCode),
@@ -511,17 +480,17 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
         if (this.getConfig().applyCustomAttributesOnSpan) {
             (0, instrumentation_1.safeExecuteInTheMiddle)(() => this.getConfig().applyCustomAttributesOnSpan(span, request, response), () => { }, true);
         }
-        this._closeHttpSpan(span, api_1.SpanKind.SERVER, startTime, oldMetricAttributes, stableMetricAttributes);
+        this._closeHttpSpan(span, api_1.SpanKind.SERVER, startTime, metricAttributes);
     }
-    _onOutgoingRequestError(span, oldMetricAttributes, stableMetricAttributes, startTime, error) {
-        (0, utils_1.setSpanWithError)(span, error, this._semconvStability);
-        stableMetricAttributes[semantic_conventions_1.ATTR_ERROR_TYPE] = error.name;
-        this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, oldMetricAttributes, stableMetricAttributes);
+    _onOutgoingRequestError(span, metricAttributes, startTime, error) {
+        (0, utils_1.setSpanWithError)(span, error);
+        metricAttributes[semantic_conventions_1.ATTR_ERROR_TYPE] = error.name;
+        this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, metricAttributes);
     }
-    _onServerResponseError(span, oldMetricAttributes, stableMetricAttributes, startTime, error) {
-        (0, utils_1.setSpanWithError)(span, error, this._semconvStability);
-        stableMetricAttributes[semantic_conventions_1.ATTR_ERROR_TYPE] = error.name;
-        this._closeHttpSpan(span, api_1.SpanKind.SERVER, startTime, oldMetricAttributes, stableMetricAttributes);
+    _onServerResponseError(span, metricAttributes, startTime, error) {
+        (0, utils_1.setSpanWithError)(span, error);
+        metricAttributes[semantic_conventions_1.ATTR_ERROR_TYPE] = error.name;
+        this._closeHttpSpan(span, api_1.SpanKind.SERVER, startTime, metricAttributes);
     }
     _startHttpSpan(name, options, ctx = api_1.context.active()) {
         /*
@@ -546,7 +515,7 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
         this._spanNotEnded.add(span);
         return span;
     }
-    _closeHttpSpan(span, spanKind, startTime, oldMetricAttributes, stableMetricAttributes) {
+    _closeHttpSpan(span, spanKind, startTime, metricAttributes) {
         if (!this._spanNotEnded.has(span)) {
             return;
         }
@@ -555,10 +524,10 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
         // Record metrics
         const duration = (0, core_1.hrTimeToMilliseconds)((0, core_1.hrTimeDuration)(startTime, (0, core_1.hrTime)()));
         if (spanKind === api_1.SpanKind.SERVER) {
-            this._recordServerDuration(duration, oldMetricAttributes, stableMetricAttributes);
+            this._recordServerDuration(duration, metricAttributes);
         }
         else if (spanKind === api_1.SpanKind.CLIENT) {
-            this._recordClientDuration(duration, oldMetricAttributes, stableMetricAttributes);
+            this._recordClientDuration(duration, metricAttributes);
         }
     }
     _callResponseHook(span, response) {
@@ -572,16 +541,16 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
             return (0, instrumentation_1.safeExecuteInTheMiddle)(() => hookFunc(request), () => { }, true);
         }
     }
-    _createHeaderCapture(semconvStability) {
+    _createHeaderCapture() {
         const config = this.getConfig();
         return {
             client: {
-                captureRequestHeaders: (0, utils_1.headerCapture)('request', config.headersToSpanAttributes?.client?.requestHeaders ?? [], semconvStability),
-                captureResponseHeaders: (0, utils_1.headerCapture)('response', config.headersToSpanAttributes?.client?.responseHeaders ?? [], semconvStability),
+                captureRequestHeaders: (0, utils_1.headerCapture)('request', config.headersToSpanAttributes?.client?.requestHeaders ?? []),
+                captureResponseHeaders: (0, utils_1.headerCapture)('response', config.headersToSpanAttributes?.client?.responseHeaders ?? []),
             },
             server: {
-                captureRequestHeaders: (0, utils_1.headerCapture)('request', config.headersToSpanAttributes?.server?.requestHeaders ?? [], semconvStability),
-                captureResponseHeaders: (0, utils_1.headerCapture)('response', config.headersToSpanAttributes?.server?.responseHeaders ?? [], semconvStability),
+                captureRequestHeaders: (0, utils_1.headerCapture)('request', config.headersToSpanAttributes?.server?.requestHeaders ?? []),
+                captureResponseHeaders: (0, utils_1.headerCapture)('response', config.headersToSpanAttributes?.server?.responseHeaders ?? []),
             },
         };
     }