npm - @opentelemetry/instrumentation-http - Versions diffs - 0.52.1 → 0.54.0 - Mend

@opentelemetry/instrumentation-http 0.52.1 → 0.54.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/README.md CHANGED Viewed

@@ -61,20 +61,56 @@ Http instrumentation has few options available to choose from. You can set the f
 | [`startOutgoingSpanHook`](https://github.com/open-telemetry/opentelemetry-js/blob/main/experimental/packages/opentelemetry-instrumentation-http/src/types.ts#L99) | `StartOutgoingSpanCustomAttributeFunction` | Function for adding custom attributes before a span is started in outgoingRequest |
 | `ignoreIncomingRequestHook` | `IgnoreIncomingRequestFunction` | Http instrumentation will not trace all incoming requests that matched with custom function |
 | `ignoreOutgoingRequestHook` | `IgnoreOutgoingRequestFunction` | Http instrumentation will not trace all outgoing requests that matched with custom function |
+| `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`](https://github.com/open-telemetry/opentelemetry-js/blob/main/experimental/packages/opentelemetry-instrumentation-http/src/types.ts#L101) | `string` | The primary server name of the matched virtual host. |
 | [`requireParentforOutgoingSpans`](https://github.com/open-telemetry/opentelemetry-js/blob/main/experimental/packages/opentelemetry-instrumentation-http/src/types.ts#L103) | Boolean | Require that is a parent span to create new span for outgoing requests. |
 | [`requireParentforIncomingSpans`](https://github.com/open-telemetry/opentelemetry-js/blob/main/experimental/packages/opentelemetry-instrumentation-http/src/types.ts#L105) | Boolean | Require that is a parent span to create new span for incoming requests. |
 | [`headersToSpanAttributes`](https://github.com/open-telemetry/opentelemetry-js/blob/main/experimental/packages/opentelemetry-instrumentation-http/src/types.ts#L107) | `object` | List of case insensitive HTTP headers to convert to span attributes. 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` |
-The following options are deprecated:
+## Semantic Conventions
-| Options | Type | Description |
-| ------- | ---- | ----------- |
-| `ignoreIncomingPaths` | `IgnoreMatcher[]` | Http instrumentation will not trace all incoming requests that match paths |
+Prior to version `0.54`, 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).
-## Semantic Conventions
+This package is capable of emitting both Semantic Convention [Version 1.7.0](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.7.0/semantic_conventions/README.md) and [Version 1.27.0](https://github.com/open-telemetry/semantic-conventions/blob/v1.27.0/docs/http/http-spans.md).
+It is controlled using the environment variable `OTEL_SEMCONV_STABILITY_OPT_IN`, which is a comma separated list of values.
+The values `http` and `http/dup` control this instrumentation.
+See details for the behavior of each of these values below.
+If neither `http` or `http/dup` is included in `OTEL_SEMCONV_STABILITY_OPT_IN`, the old experimental semantic conventions will be used by default.
+### Stable Semantic Conventions 1.27
+Enabled when `OTEL_SEMCONV_STABILITY_OPT_IN` contains `http` OR `http/dup`.
+This is the recommended configuration, and will soon become the default behavior.
+Follow all requirements and recommendations of HTTP Client and Server Semantic Conventions Version 1.27.0 for [spans](https://github.com/open-telemetry/semantic-conventions/blob/v1.27.0/docs/http/http-spans.md) and [metrics](https://github.com/open-telemetry/semantic-conventions/blob/v1.27.0/docs/http/http-metrics.md), including all required and recommended attributes.
+Metrics Exported:
+- [`http.server.request.duration`](https://github.com/open-telemetry/semantic-conventions/blob/v1.27.0/docs/http/http-metrics.md#metric-httpserverrequestduration)
+- [`http.client.request.duration`](https://github.com/open-telemetry/semantic-conventions/blob/v1.27.0/docs/http/http-metrics.md#metric-httpclientrequestduration)
+### Upgrading Semantic Conventions
+When upgrading to the new semantic conventions, it is recommended to do so in the following order:
+1. Upgrade `@opentelemetry/instrumentation-http` to the latest version
+2. Set `OTEL_SEMCONV_STABILITY_OPT_IN=http/dup` to emit both old and new semantic conventions
+3. Modify alerts, dashboards, metrics, and other processes to expect the new semantic conventions
+4. Set `OTEL_SEMCONV_STABILITY_OPT_IN=http` to emit only the new semantic conventions
+This will cause both the old and new semantic conventions to be emitted during the transition period.
+### Legacy Behavior (default)
+Enabled when `OTEL_SEMCONV_STABILITY_OPT_IN` contains `http/dup` or DOES NOT CONTAIN `http`.
+This is the current default behavior.
+Create HTTP client spans which implement Semantic Convention [Version 1.7.0](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.7.0/semantic_conventions/README.md).
+#### Server Spans (legacy)
-This package uses `@opentelemetry/semantic-conventions` version `1.22+`, which implements Semantic Convention [Version 1.7.0](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.7.0/semantic_conventions/README.md)
+When `OTEL_SEMCONV_STABILITY_OPT_IN` is not set or includes `http/dup`, this module implements Semantic Convention [Version 1.7.0](https://github.com/open-telemetry/opentelemetry-specification/blob/v1.7.0/semantic_conventions/README.md).
 Attributes collected:

package/build/src/http.d.ts CHANGED Viewed

@@ -4,16 +4,21 @@ import * as url from 'url';
 import { Func, HttpInstrumentationConfig, HttpRequestArgs } from './types';
 import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
 /**
- * Http instrumentation instrumentation for Opentelemetry
+ * `node:http` and `node:https` instrumentation for OpenTelemetry
  */
 export declare class HttpInstrumentation extends InstrumentationBase<HttpInstrumentationConfig> {
     /** keep track on spans not ended */
     private readonly _spanNotEnded;
     private _headerCapture;
-    private _httpServerDurationHistogram;
-    private _httpClientDurationHistogram;
+    private _oldHttpServerDurationHistogram;
+    private _stableHttpServerDurationHistogram;
+    private _oldHttpClientDurationHistogram;
+    private _stableHttpClientDurationHistogram;
+    private _semconvStability;
     constructor(config?: HttpInstrumentationConfig);
     protected _updateMetricInstruments(): void;
+    private _recordServerDuration;
+    private _recordClientDuration;
     setConfig(config?: HttpInstrumentationConfig): void;
     init(): [
         InstrumentationNodeModuleDefinition,
@@ -42,7 +47,8 @@ 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 metricAttributes metric attributes
+     * @param oldMetricAttributes metric attributes for old semantic conventions
+     * @param stableMetricAttributes metric attributes for new semantic conventions
      */
     private _traceClientRequest;
     private _incomingRequestFunction;

package/build/src/http.js CHANGED Viewed

@@ -20,33 +20,90 @@ const api_1 = require("@opentelemetry/api");
 const core_1 = require("@opentelemetry/core");
 const semver = require("semver");
 const url = require("url");
-const utils = require("./utils");
 const version_1 = require("./version");
 const instrumentation_1 = require("@opentelemetry/instrumentation");
 const core_2 = require("@opentelemetry/core");
 const events_1 = require("events");
 const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const utils_1 = require("./utils");
 /**
- * Http instrumentation instrumentation for Opentelemetry
+ * `node:http` and `node:https` instrumentation for OpenTelemetry
  */
 class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
     constructor(config = {}) {
         super('@opentelemetry/instrumentation-http', version_1.VERSION, config);
         /** keep track on spans not ended */
         this._spanNotEnded = new WeakSet();
+        this._semconvStability = 2 /* OLD */;
         this._headerCapture = this._createHeaderCapture();
+        for (const entry in (0, core_2.getEnv)().OTEL_SEMCONV_STABILITY_OPT_IN) {
+            if (entry.toLowerCase() === 'http/dup') {
+                // http/dup takes highest precedence. If it is found, there is no need to read the rest of the list
+                this._semconvStability = 3 /* DUPLICATE */;
+                break;
+            }
+            else if (entry.toLowerCase() === 'http') {
+                this._semconvStability = 1 /* STABLE */;
+            }
+        }
     }
     _updateMetricInstruments() {
-        this._httpServerDurationHistogram = this.meter.createHistogram('http.server.duration', {
+        this._oldHttpServerDurationHistogram = this.meter.createHistogram('http.server.duration', {
             description: 'Measures the duration of inbound HTTP requests.',
             unit: 'ms',
             valueType: api_1.ValueType.DOUBLE,
         });
-        this._httpClientDurationHistogram = this.meter.createHistogram('http.client.duration', {
+        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, {
+            description: 'Duration of HTTP server requests.',
+            unit: 's',
+            valueType: api_1.ValueType.DOUBLE,
+            advice: {
+                explicitBucketBoundaries: [
+                    0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1, 2.5, 5,
+                    7.5, 10,
+                ],
+            },
+        });
+        this._stableHttpClientDurationHistogram = this.meter.createHistogram(semantic_conventions_1.METRIC_HTTP_CLIENT_REQUEST_DURATION, {
+            description: 'Duration of HTTP client requests.',
+            unit: 's',
+            valueType: api_1.ValueType.DOUBLE,
+            advice: {
+                explicitBucketBoundaries: [
+                    0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1, 2.5, 5,
+                    7.5, 10,
+                ],
+            },
+        });
+    }
+    _recordServerDuration(durationMs, oldAttributes, stableAttributes) {
+        if ((this._semconvStability & 2 /* OLD */) ===
+            2 /* OLD */) {
+            // old histogram is counted in MS
+            this._oldHttpServerDurationHistogram.record(durationMs, oldAttributes);
+        }
+        if ((this._semconvStability & 1 /* STABLE */) ===
+            1 /* STABLE */) {
+            // stable histogram is counted in S
+            this._stableHttpServerDurationHistogram.record(durationMs / 1000, stableAttributes);
+        }
+    }
+    _recordClientDuration(durationMs, oldAttributes, stableAttributes) {
+        if ((this._semconvStability & 2 /* OLD */) ===
+            2 /* OLD */) {
+            // old histogram is counted in MS
+            this._oldHttpClientDurationHistogram.record(durationMs, oldAttributes);
+        }
+        if ((this._semconvStability & 1 /* STABLE */) ===
+            1 /* STABLE */) {
+            // stable histogram is counted in S
+            this._stableHttpClientDurationHistogram.record(durationMs / 1000, stableAttributes);
+        }
     }
     setConfig(config = {}) {
         super.setConfig(config);
@@ -57,30 +114,60 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
     }
     _getHttpInstrumentation() {
         return new instrumentation_1.InstrumentationNodeModuleDefinition('http', ['*'], (moduleExports) => {
-            this._wrap(moduleExports, 'request', this._getPatchOutgoingRequestFunction('http'));
-            this._wrap(moduleExports, 'get', this._getPatchOutgoingGetFunction(moduleExports.request));
-            this._wrap(moduleExports.Server.prototype, 'emit', this._getPatchIncomingRequestFunction('http'));
+            const isESM = moduleExports[Symbol.toStringTag] === 'Module';
+            if (!this.getConfig().disableOutgoingRequestInstrumentation) {
+                const patchedRequest = this._wrap(moduleExports, 'request', this._getPatchOutgoingRequestFunction('http'));
+                const patchedGet = this._wrap(moduleExports, 'get', this._getPatchOutgoingGetFunction(patchedRequest));
+                if (isESM) {
+                    // To handle `import http from 'http'`, which returns the default
+                    // export, we need to set `module.default.*`.
+                    moduleExports.default.request = patchedRequest;
+                    moduleExports.default.get = patchedGet;
+                }
+            }
+            if (!this.getConfig().disableIncomingRequestInstrumentation) {
+                this._wrap(moduleExports.Server.prototype, 'emit', this._getPatchIncomingRequestFunction('http'));
+            }
             return moduleExports;
         }, (moduleExports) => {
             if (moduleExports === undefined)
                 return;
-            this._unwrap(moduleExports, 'request');
-            this._unwrap(moduleExports, 'get');
-            this._unwrap(moduleExports.Server.prototype, 'emit');
+            if (!this.getConfig().disableOutgoingRequestInstrumentation) {
+                this._unwrap(moduleExports, 'request');
+                this._unwrap(moduleExports, 'get');
+            }
+            if (!this.getConfig().disableIncomingRequestInstrumentation) {
+                this._unwrap(moduleExports.Server.prototype, 'emit');
+            }
         });
     }
     _getHttpsInstrumentation() {
         return new instrumentation_1.InstrumentationNodeModuleDefinition('https', ['*'], (moduleExports) => {
-            this._wrap(moduleExports, 'request', this._getPatchHttpsOutgoingRequestFunction('https'));
-            this._wrap(moduleExports, 'get', this._getPatchHttpsOutgoingGetFunction(moduleExports.request));
-            this._wrap(moduleExports.Server.prototype, 'emit', this._getPatchIncomingRequestFunction('https'));
+            const isESM = moduleExports[Symbol.toStringTag] === 'Module';
+            if (!this.getConfig().disableOutgoingRequestInstrumentation) {
+                const patchedRequest = this._wrap(moduleExports, 'request', this._getPatchHttpsOutgoingRequestFunction('https'));
+                const patchedGet = this._wrap(moduleExports, 'get', this._getPatchHttpsOutgoingGetFunction(patchedRequest));
+                if (isESM) {
+                    // To handle `import https from 'https'`, which returns the default
+                    // export, we need to set `module.default.*`.
+                    moduleExports.default.request = patchedRequest;
+                    moduleExports.default.get = patchedGet;
+                }
+            }
+            if (!this.getConfig().disableIncomingRequestInstrumentation) {
+                this._wrap(moduleExports.Server.prototype, 'emit', this._getPatchIncomingRequestFunction('https'));
+            }
             return moduleExports;
         }, (moduleExports) => {
             if (moduleExports === undefined)
                 return;
-            this._unwrap(moduleExports, 'request');
-            this._unwrap(moduleExports, 'get');
-            this._unwrap(moduleExports.Server.prototype, 'emit');
+            if (!this.getConfig().disableOutgoingRequestInstrumentation) {
+                this._unwrap(moduleExports, 'request');
+                this._unwrap(moduleExports, 'get');
+            }
+            if (!this.getConfig().disableIncomingRequestInstrumentation) {
+                this._unwrap(moduleExports.Server.prototype, 'emit');
+            }
         });
     }
     /**
@@ -159,9 +246,10 @@ 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 metricAttributes metric attributes
+     * @param oldMetricAttributes metric attributes for old semantic conventions
+     * @param stableMetricAttributes metric attributes for new semantic conventions
      */
-    _traceClientRequest(request, span, startTime, metricAttributes) {
+    _traceClientRequest(request, span, startTime, oldMetricAttributes, stableMetricAttributes) {
         if (this.getConfig().requestHook) {
             this._callRequestHook(span, request);
         }
@@ -179,9 +267,9 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
             if (request.listenerCount('response') <= 1) {
                 response.resume();
             }
-            const responseAttributes = utils.getOutgoingRequestAttributesOnResponse(response);
+            const responseAttributes = (0, utils_1.getOutgoingRequestAttributesOnResponse)(response, this._semconvStability);
             span.setAttributes(responseAttributes);
-            metricAttributes = Object.assign(metricAttributes, utils.getOutgoingRequestMetricAttributesOnResponse(responseAttributes));
+            oldMetricAttributes = Object.assign(oldMetricAttributes, (0, utils_1.getOutgoingRequestMetricAttributesOnResponse)(responseAttributes));
             if (this.getConfig().responseHook) {
                 this._callResponseHook(span, response);
             }
@@ -199,15 +287,16 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                     status = { code: api_1.SpanStatusCode.ERROR };
                 }
                 else {
+                    // behaves same for new and old semconv
                     status = {
-                        code: utils.parseResponseStatus(api_1.SpanKind.CLIENT, response.statusCode),
+                        code: (0, utils_1.parseResponseStatus)(api_1.SpanKind.CLIENT, response.statusCode),
                     };
                 }
                 span.setStatus(status);
                 if (this.getConfig().applyCustomAttributesOnSpan) {
                     (0, instrumentation_1.safeExecuteInTheMiddle)(() => this.getConfig().applyCustomAttributesOnSpan(span, request, response), () => { }, true);
                 }
-                this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, metricAttributes);
+                this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, oldMetricAttributes, stableMetricAttributes);
             };
             response.on('end', endHandler);
             // See https://github.com/open-telemetry/opentelemetry-js/pull/3625#issuecomment-1475673533
@@ -220,12 +309,12 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                     return;
                 }
                 responseFinished = true;
-                utils.setSpanWithError(span, error);
+                (0, utils_1.setSpanWithError)(span, error, this._semconvStability);
                 span.setStatus({
                     code: api_1.SpanStatusCode.ERROR,
                     message: error.message,
                 });
-                this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, metricAttributes);
+                this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, oldMetricAttributes, stableMetricAttributes);
             });
         });
         request.on('close', () => {
@@ -234,7 +323,7 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                 return;
             }
             responseFinished = true;
-            this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, metricAttributes);
+            this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, oldMetricAttributes, stableMetricAttributes);
         });
         request.on(events_1.errorMonitor, (error) => {
             this._diag.debug('outgoingRequest on request error()', error);
@@ -242,8 +331,8 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                 return;
             }
             responseFinished = true;
-            utils.setSpanWithError(span, error);
-            this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, metricAttributes);
+            (0, utils_1.setSpanWithError)(span, error, this._semconvStability);
+            this._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, oldMetricAttributes, stableMetricAttributes);
         });
         this._diag.debug('http.ClientRequest return request');
         return request;
@@ -257,17 +346,13 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
             }
             const request = args[0];
             const response = args[1];
-            const pathname = request.url
-                ? url.parse(request.url).pathname || '/'
-                : '/';
             const method = request.method || 'GET';
             instrumentation._diag.debug(`${component} instrumentation incomingRequest`);
-            if (utils.isIgnored(pathname, instrumentation.getConfig().ignoreIncomingPaths, (e) => instrumentation._diag.error('caught ignoreIncomingPaths error: ', e)) ||
-                (0, instrumentation_1.safeExecuteInTheMiddle)(() => { var _a, _b; return (_b = (_a = instrumentation.getConfig()).ignoreIncomingRequestHook) === null || _b === void 0 ? void 0 : _b.call(_a, request); }, (e) => {
-                    if (e != null) {
-                        instrumentation._diag.error('caught ignoreIncomingRequestHook error: ', e);
-                    }
-                }, true)) {
+            if ((0, instrumentation_1.safeExecuteInTheMiddle)(() => { var _a, _b; return (_b = (_a = instrumentation.getConfig()).ignoreIncomingRequestHook) === null || _b === void 0 ? void 0 : _b.call(_a, request); }, (e) => {
+                if (e != null) {
+                    instrumentation._diag.error('caught ignoreIncomingRequestHook error: ', e);
+                }
+            }, true)) {
                 return api_1.context.with((0, core_1.suppressTracing)(api_1.context.active()), () => {
                     api_1.context.bind(api_1.context.active(), request);
                     api_1.context.bind(api_1.context.active(), response);
@@ -275,17 +360,28 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                 });
             }
             const headers = request.headers;
-            const spanAttributes = utils.getIncomingRequestAttributes(request, {
+            const spanAttributes = (0, utils_1.getIncomingRequestAttributes)(request, {
                 component: component,
                 serverName: instrumentation.getConfig().serverName,
                 hookAttributes: instrumentation._callStartSpanHook(request, instrumentation.getConfig().startIncomingSpanHook),
+                semconvStability: instrumentation._semconvStability,
             });
             const spanOptions = {
                 kind: api_1.SpanKind.SERVER,
                 attributes: spanAttributes,
             };
             const startTime = (0, core_1.hrTime)();
-            const metricAttributes = utils.getIncomingRequestMetricAttributes(spanAttributes);
+            const oldMetricAttributes = (0, utils_1.getIncomingRequestMetricAttributes)(spanAttributes);
+            // request method and url.scheme are both required span attributes
+            const stableMetricAttributes = {
+                [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] =
+                    spanAttributes[semantic_conventions_1.ATTR_NETWORK_PROTOCOL_VERSION];
+            }
             const ctx = api_1.propagation.extract(api_1.ROOT_CONTEXT, headers);
             const span = instrumentation._startHttpSpan(method, spanOptions, ctx);
             const rpcMetadata = {
@@ -308,16 +404,16 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                     if (hasError) {
                         return;
                     }
-                    instrumentation._onServerResponseFinish(request, response, span, metricAttributes, startTime);
+                    instrumentation._onServerResponseFinish(request, response, span, oldMetricAttributes, stableMetricAttributes, startTime);
                 });
                 response.on(events_1.errorMonitor, (err) => {
                     hasError = true;
-                    instrumentation._onServerResponseError(span, metricAttributes, startTime, err);
+                    instrumentation._onServerResponseError(span, oldMetricAttributes, stableMetricAttributes, startTime, err);
                 });
                 return (0, instrumentation_1.safeExecuteInTheMiddle)(() => original.apply(this, [event, ...args]), error => {
                     if (error) {
-                        utils.setSpanWithError(span, error);
-                        instrumentation._closeHttpSpan(span, api_1.SpanKind.SERVER, startTime, metricAttributes);
+                        (0, utils_1.setSpanWithError)(span, error, instrumentation._semconvStability);
+                        instrumentation._closeHttpSpan(span, api_1.SpanKind.SERVER, startTime, oldMetricAttributes, stableMetricAttributes);
                         throw error;
                     }
                 });
@@ -327,14 +423,14 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
     _outgoingRequestFunction(component, original) {
         const instrumentation = this;
         return function outgoingRequest(options, ...args) {
-            if (!utils.isValidOptionsType(options)) {
+            if (!(0, utils_1.isValidOptionsType)(options)) {
                 return original.apply(this, [options, ...args]);
             }
             const extraOptions = typeof args[0] === 'object' &&
                 (typeof options === 'string' || options instanceof url.URL)
                 ? args.shift()
                 : undefined;
-            const { origin, pathname, method, optionsParsed } = utils.getRequestInfo(options, extraOptions);
+            const { method, optionsParsed } = (0, utils_1.getRequestInfo)(options, extraOptions);
             /**
              * Node 8's https module directly call the http one so to avoid creating
              * 2 span for the same request we need to check that the protocol is correct
@@ -345,27 +441,42 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                 optionsParsed.protocol === 'https:') {
                 return original.apply(this, [optionsParsed, ...args]);
             }
-            if (utils.isIgnored(origin + pathname, instrumentation.getConfig().ignoreOutgoingUrls, (e) => instrumentation._diag.error('caught ignoreOutgoingUrls error: ', e)) ||
-                (0, instrumentation_1.safeExecuteInTheMiddle)(() => {
-                    var _a, _b;
-                    return (_b = (_a = instrumentation
-                        .getConfig()).ignoreOutgoingRequestHook) === null || _b === void 0 ? void 0 : _b.call(_a, optionsParsed);
-                }, (e) => {
-                    if (e != null) {
-                        instrumentation._diag.error('caught ignoreOutgoingRequestHook error: ', e);
-                    }
-                }, true)) {
+            if ((0, instrumentation_1.safeExecuteInTheMiddle)(() => {
+                var _a, _b;
+                return (_b = (_a = instrumentation
+                    .getConfig()).ignoreOutgoingRequestHook) === null || _b === void 0 ? void 0 : _b.call(_a, optionsParsed);
+            }, (e) => {
+                if (e != null) {
+                    instrumentation._diag.error('caught ignoreOutgoingRequestHook error: ', e);
+                }
+            }, true)) {
                 return original.apply(this, [optionsParsed, ...args]);
             }
-            const { hostname, port } = utils.extractHostnameAndPort(optionsParsed);
-            const attributes = utils.getOutgoingRequestAttributes(optionsParsed, {
+            const { hostname, port } = (0, utils_1.extractHostnameAndPort)(optionsParsed);
+            const attributes = (0, utils_1.getOutgoingRequestAttributes)(optionsParsed, {
                 component,
                 port,
                 hostname,
                 hookAttributes: instrumentation._callStartSpanHook(optionsParsed, instrumentation.getConfig().startOutgoingSpanHook),
-            });
+            }, instrumentation._semconvStability);
             const startTime = (0, core_1.hrTime)();
-            const metricAttributes = utils.getOutgoingRequestMetricAttributes(attributes);
+            const oldMetricAttributes = (0, utils_1.getOutgoingRequestMetricAttributes)(attributes);
+            // request method, server address, and server port are both required span attributes
+            const stableMetricAttributes = {
+                [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] =
+                    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] =
+                    attributes[semantic_conventions_1.ATTR_NETWORK_PROTOCOL_VERSION];
+            }
             const spanOptions = {
                 kind: api_1.SpanKind.CLIENT,
                 attributes,
@@ -393,23 +504,24 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
                 }
                 const request = (0, instrumentation_1.safeExecuteInTheMiddle)(() => original.apply(this, [optionsParsed, ...args]), error => {
                     if (error) {
-                        utils.setSpanWithError(span, error);
-                        instrumentation._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, metricAttributes);
+                        (0, utils_1.setSpanWithError)(span, error, instrumentation._semconvStability);
+                        instrumentation._closeHttpSpan(span, api_1.SpanKind.CLIENT, startTime, oldMetricAttributes, stableMetricAttributes);
                         throw error;
                     }
                 });
                 instrumentation._diag.debug(`${component} instrumentation outgoingRequest`);
                 api_1.context.bind(parentContext, request);
-                return instrumentation._traceClientRequest(request, span, startTime, metricAttributes);
+                return instrumentation._traceClientRequest(request, span, startTime, oldMetricAttributes, stableMetricAttributes);
             });
         };
     }
-    _onServerResponseFinish(request, response, span, metricAttributes, startTime) {
-        const attributes = utils.getIncomingRequestAttributesOnResponse(request, response);
-        metricAttributes = Object.assign(metricAttributes, utils.getIncomingRequestMetricAttributesOnResponse(attributes));
+    _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));
         this._headerCapture.server.captureResponseHeaders(span, header => response.getHeader(header));
         span.setAttributes(attributes).setStatus({
-            code: utils.parseResponseStatus(api_1.SpanKind.SERVER, response.statusCode),
+            code: (0, utils_1.parseResponseStatus)(api_1.SpanKind.SERVER, response.statusCode),
         });
         const route = attributes[semantic_conventions_1.SEMATTRS_HTTP_ROUTE];
         if (route) {
@@ -418,11 +530,12 @@ 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, metricAttributes);
+        this._closeHttpSpan(span, api_1.SpanKind.SERVER, startTime, oldMetricAttributes, stableMetricAttributes);
     }
-    _onServerResponseError(span, metricAttributes, startTime, error) {
-        utils.setSpanWithError(span, error);
-        this._closeHttpSpan(span, api_1.SpanKind.SERVER, startTime, metricAttributes);
+    _onServerResponseError(span, oldMetricAttributes, stableMetricAttributes, startTime, error) {
+        (0, utils_1.setSpanWithError)(span, error, this._semconvStability);
+        // TODO get error attributes for metrics
+        this._closeHttpSpan(span, api_1.SpanKind.SERVER, startTime, oldMetricAttributes, stableMetricAttributes);
     }
     _startHttpSpan(name, options, ctx = api_1.context.active()) {
         /*
@@ -446,7 +559,7 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
         this._spanNotEnded.add(span);
         return span;
     }
-    _closeHttpSpan(span, spanKind, startTime, metricAttributes) {
+    _closeHttpSpan(span, spanKind, startTime, oldMetricAttributes, stableMetricAttributes) {
         if (!this._spanNotEnded.has(span)) {
             return;
         }
@@ -455,10 +568,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._httpServerDurationHistogram.record(duration, metricAttributes);
+            this._recordServerDuration(duration, oldMetricAttributes, stableMetricAttributes);
         }
         else if (spanKind === api_1.SpanKind.CLIENT) {
-            this._httpClientDurationHistogram.record(duration, metricAttributes);
+            this._recordClientDuration(duration, oldMetricAttributes, stableMetricAttributes);
         }
     }
     _callResponseHook(span, response) {
@@ -477,12 +590,12 @@ class HttpInstrumentation extends instrumentation_1.InstrumentationBase {
         const config = this.getConfig();
         return {
             client: {
-                captureRequestHeaders: utils.headerCapture('request', (_c = (_b = (_a = config.headersToSpanAttributes) === null || _a === void 0 ? void 0 : _a.client) === null || _b === void 0 ? void 0 : _b.requestHeaders) !== null && _c !== void 0 ? _c : []),
-                captureResponseHeaders: utils.headerCapture('response', (_f = (_e = (_d = config.headersToSpanAttributes) === null || _d === void 0 ? void 0 : _d.client) === null || _e === void 0 ? void 0 : _e.responseHeaders) !== null && _f !== void 0 ? _f : []),
+                captureRequestHeaders: (0, utils_1.headerCapture)('request', (_c = (_b = (_a = config.headersToSpanAttributes) === null || _a === void 0 ? void 0 : _a.client) === null || _b === void 0 ? void 0 : _b.requestHeaders) !== null && _c !== void 0 ? _c : []),
+                captureResponseHeaders: (0, utils_1.headerCapture)('response', (_f = (_e = (_d = config.headersToSpanAttributes) === null || _d === void 0 ? void 0 : _d.client) === null || _e === void 0 ? void 0 : _e.responseHeaders) !== null && _f !== void 0 ? _f : []),
             },
             server: {
-                captureRequestHeaders: utils.headerCapture('request', (_j = (_h = (_g = config.headersToSpanAttributes) === null || _g === void 0 ? void 0 : _g.server) === null || _h === void 0 ? void 0 : _h.requestHeaders) !== null && _j !== void 0 ? _j : []),
-                captureResponseHeaders: utils.headerCapture('response', (_m = (_l = (_k = config.headersToSpanAttributes) === null || _k === void 0 ? void 0 : _k.server) === null || _l === void 0 ? void 0 : _l.responseHeaders) !== null && _m !== void 0 ? _m : []),
+                captureRequestHeaders: (0, utils_1.headerCapture)('request', (_j = (_h = (_g = config.headersToSpanAttributes) === null || _g === void 0 ? void 0 : _g.server) === null || _h === void 0 ? void 0 : _h.requestHeaders) !== null && _j !== void 0 ? _j : []),
+                captureResponseHeaders: (0, utils_1.headerCapture)('response', (_m = (_l = (_k = config.headersToSpanAttributes) === null || _k === void 0 ? void 0 : _k.server) === null || _l === void 0 ? void 0 : _l.responseHeaders) !== null && _m !== void 0 ? _m : []),
             },
         };
     }