@opentelemetry/instrumentation-http 0.53.0 → 0.54.0

package/build/src/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.headerCapture = exports.getIncomingRequestMetricAttributesOnResponse = exports.getIncomingRequestAttributesOnResponse = exports.getIncomingRequestMetricAttributes = exports.getIncomingRequestAttributes = exports.getOutgoingRequestMetricAttributesOnResponse = exports.getOutgoingRequestAttributesOnResponse = exports.setAttributesFromHttpKind = exports.getOutgoingRequestMetricAttributes = exports.getOutgoingRequestAttributes = exports.extractHostnameAndPort = exports.isValidOptionsType = exports.getRequestInfo = exports.isCompressed = exports.setResponseContentLengthAttribute = exports.setRequestContentLengthAttribute = exports.setSpanWithError = exports.isIgnored = exports.satisfiesPattern = exports.parseResponseStatus = exports.getAbsoluteUrl = void 0;
+exports.headerCapture = exports.getIncomingStableRequestMetricAttributesOnResponse = exports.getIncomingRequestMetricAttributesOnResponse = exports.getIncomingRequestAttributesOnResponse = exports.getIncomingRequestMetricAttributes = exports.getIncomingRequestAttributes = exports.getRemoteClientAddress = exports.getOutgoingRequestMetricAttributesOnResponse = exports.getOutgoingRequestAttributesOnResponse = exports.setAttributesFromHttpKind = exports.getOutgoingRequestMetricAttributes = exports.getOutgoingRequestAttributes = exports.extractHostnameAndPort = exports.isValidOptionsType = exports.getRequestInfo = exports.isCompressed = exports.setResponseContentLengthAttribute = exports.setRequestContentLengthAttribute = exports.setSpanWithError = exports.satisfiesPattern = exports.parseResponseStatus = exports.getAbsoluteUrl = void 0;
 /*
  * Copyright The OpenTelemetry Authors
  *
@@ -21,6 +21,7 @@ const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
 const core_1 = require("@opentelemetry/core");
 const url = require("url");
 const AttributeNames_1 = require("./enums/AttributeNames");
+const forwardedParse = require("forwarded-parse");
 /**
  * Get an absolute url
  */
@@ -75,44 +76,22 @@ const satisfiesPattern = (constant, pattern) => {
     }
 };
 exports.satisfiesPattern = satisfiesPattern;
-/**
- * Check whether the given request is ignored by configuration
- * It will not re-throw exceptions from `list` provided by the client
- * @param constant e.g URL of request
- * @param [list] List of ignore patterns
- * @param [onException] callback for doing something when an exception has
- *     occurred
- */
-const isIgnored = (constant, list, onException) => {
-    if (!list) {
-        // No ignored urls - trace everything
-        return false;
-    }
-    // Try/catch outside the loop for failing fast
-    try {
-        for (const pattern of list) {
-            if ((0, exports.satisfiesPattern)(constant, pattern)) {
-                return true;
-            }
-        }
-    }
-    catch (e) {
-        if (onException) {
-            onException(e);
-        }
-    }
-    return false;
-};
-exports.isIgnored = isIgnored;
 /**
  * Sets the span with the error passed in params
  * @param {Span} span the span that need to be set
  * @param {Error} error error that will be set to span
+ * @param {SemconvStability} semconvStability determines which semconv version to use
  */
-const setSpanWithError = (span, error) => {
+const setSpanWithError = (span, error, semconvStability) => {
     const message = error.message;
-    span.setAttribute(AttributeNames_1.AttributeNames.HTTP_ERROR_NAME, error.name);
-    span.setAttribute(AttributeNames_1.AttributeNames.HTTP_ERROR_MESSAGE, message);
+    if ((semconvStability & 2 /* OLD */) === 2 /* OLD */) {
+        span.setAttribute(AttributeNames_1.AttributeNames.HTTP_ERROR_NAME, error.name);
+        span.setAttribute(AttributeNames_1.AttributeNames.HTTP_ERROR_MESSAGE, message);
+    }
+    if ((semconvStability & 1 /* STABLE */) ===
+        1 /* STABLE */) {
+        span.setAttribute(semantic_conventions_1.ATTR_ERROR_TYPE, error.name);
+    }
     span.setStatus({ code: api_1.SpanStatusCode.ERROR, message });
     span.recordException(error);
 };
@@ -120,7 +99,7 @@ exports.setSpanWithError = setSpanWithError;
 /**
  * Adds attributes for request content-length and content-encoding HTTP headers
  * @param { IncomingMessage } Request object whose headers will be analyzed
- * @param { SpanAttributes } SpanAttributes object to be modified
+ * @param { Attributes } Attributes object to be modified
  */
 const setRequestContentLengthAttribute = (request, attributes) => {
     const length = getContentLength(request.headers);
@@ -137,7 +116,9 @@ exports.setRequestContentLengthAttribute = setRequestContentLengthAttribute;
 /**
  * Adds attributes for response content-length and content-encoding HTTP headers
  * @param { IncomingMessage } Response object whose headers will be analyzed
- * @param { SpanAttributes } SpanAttributes object to be modified
+ * @param { Attributes } Attributes object to be modified
+ *
+ * @deprecated this is for an older version of semconv. It is retained for compatibility using OTEL_SEMCONV_STABILITY_OPT_IN
  */
 const setResponseContentLengthAttribute = (response, attributes) => {
     const length = getContentLength(response.headers);
@@ -258,32 +239,55 @@ exports.extractHostnameAndPort = extractHostnameAndPort;
 /**
  * Returns outgoing request attributes scoped to the options passed to the request
  * @param {ParsedRequestOptions} requestOptions the same options used to make the request
- * @param {{ component: string, hostname: string, hookAttributes?: SpanAttributes }} options used to pass data needed to create attributes
+ * @param {{ component: string, hostname: string, hookAttributes?: Attributes }} options used to pass data needed to create attributes
+ * @param {SemconvStability} semconvStability determines which semconv version to use
  */
-const getOutgoingRequestAttributes = (requestOptions, options) => {
-    var _a;
+const getOutgoingRequestAttributes = (requestOptions, options, semconvStability) => {
+    var _a, _b;
     const hostname = options.hostname;
     const port = options.port;
-    const requestMethod = requestOptions.method;
-    const method = requestMethod ? requestMethod.toUpperCase() : 'GET';
+    const method = (_a = requestOptions.method) !== null && _a !== void 0 ? _a : 'GET';
+    const normalizedMethod = normalizeMethod(method);
     const headers = requestOptions.headers || {};
     const userAgent = headers['user-agent'];
-    const attributes = {
-        [semantic_conventions_1.SEMATTRS_HTTP_URL]: (0, exports.getAbsoluteUrl)(requestOptions, headers, `${options.component}:`),
+    const urlFull = (0, exports.getAbsoluteUrl)(requestOptions, headers, `${options.component}:`);
+    const oldAttributes = {
+        [semantic_conventions_1.SEMATTRS_HTTP_URL]: urlFull,
         [semantic_conventions_1.SEMATTRS_HTTP_METHOD]: method,
         [semantic_conventions_1.SEMATTRS_HTTP_TARGET]: requestOptions.path || '/',
         [semantic_conventions_1.SEMATTRS_NET_PEER_NAME]: hostname,
-        [semantic_conventions_1.SEMATTRS_HTTP_HOST]: (_a = headers.host) !== null && _a !== void 0 ? _a : `${hostname}:${port}`,
+        [semantic_conventions_1.SEMATTRS_HTTP_HOST]: (_b = headers.host) !== null && _b !== void 0 ? _b : `${hostname}:${port}`,
+    };
+    const newAttributes = {
+        // Required attributes
+        [semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD]: normalizedMethod,
+        [semantic_conventions_1.ATTR_SERVER_ADDRESS]: hostname,
+        [semantic_conventions_1.ATTR_SERVER_PORT]: Number(port),
+        [semantic_conventions_1.ATTR_URL_FULL]: urlFull,
+        // leaving out protocol version, it is not yet negotiated
+        // leaving out protocol name, it is only required when protocol version is set
+        // retries and redirects not supported
+        // Opt-in attributes left off for now
     };
+    // conditionally required if request method required case normalization
+    if (method !== normalizedMethod) {
+        newAttributes[semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD_ORIGINAL] = method;
+    }
     if (userAgent !== undefined) {
-        attributes[semantic_conventions_1.SEMATTRS_HTTP_USER_AGENT] = userAgent;
+        oldAttributes[semantic_conventions_1.SEMATTRS_HTTP_USER_AGENT] = userAgent;
+    }
+    switch (semconvStability) {
+        case 1 /* STABLE */:
+            return Object.assign(newAttributes, options.hookAttributes);
+        case 2 /* OLD */:
+            return Object.assign(oldAttributes, options.hookAttributes);
     }
-    return Object.assign(attributes, options.hookAttributes);
+    return Object.assign(oldAttributes, newAttributes, options.hookAttributes);
 };
 exports.getOutgoingRequestAttributes = getOutgoingRequestAttributes;
 /**
  * Returns outgoing request Metric attributes scoped to the request data
- * @param {SpanAttributes} spanAttributes the span attributes
+ * @param {Attributes} spanAttributes the span attributes
  */
 const getOutgoingRequestMetricAttributes = (spanAttributes) => {
     const metricAttributes = {};
@@ -313,28 +317,42 @@ exports.setAttributesFromHttpKind = setAttributesFromHttpKind;
 /**
  * Returns outgoing request attributes scoped to the response data
  * @param {IncomingMessage} response the response object
- * @param {{ hostname: string }} options used to pass data needed to create attributes
+ * @param {SemconvStability} semconvStability determines which semconv version to use
  */
-const getOutgoingRequestAttributesOnResponse = (response) => {
+const getOutgoingRequestAttributesOnResponse = (response, semconvStability) => {
     const { statusCode, statusMessage, httpVersion, socket } = response;
-    const attributes = {};
+    const oldAttributes = {};
+    const stableAttributes = {};
+    if (statusCode != null) {
+        stableAttributes[semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE] = statusCode;
+    }
     if (socket) {
         const { remoteAddress, remotePort } = socket;
-        attributes[semantic_conventions_1.SEMATTRS_NET_PEER_IP] = remoteAddress;
-        attributes[semantic_conventions_1.SEMATTRS_NET_PEER_PORT] = remotePort;
+        oldAttributes[semantic_conventions_1.SEMATTRS_NET_PEER_IP] = remoteAddress;
+        oldAttributes[semantic_conventions_1.SEMATTRS_NET_PEER_PORT] = remotePort;
+        // Recommended
+        stableAttributes[semantic_conventions_1.ATTR_NETWORK_PEER_ADDRESS] = remoteAddress;
+        stableAttributes[semantic_conventions_1.ATTR_NETWORK_PEER_PORT] = remotePort;
+        stableAttributes[semantic_conventions_1.ATTR_NETWORK_PROTOCOL_VERSION] = response.httpVersion;
     }
-    (0, exports.setResponseContentLengthAttribute)(response, attributes);
+    (0, exports.setResponseContentLengthAttribute)(response, oldAttributes);
     if (statusCode) {
-        attributes[semantic_conventions_1.SEMATTRS_HTTP_STATUS_CODE] = statusCode;
-        attributes[AttributeNames_1.AttributeNames.HTTP_STATUS_TEXT] = (statusMessage || '').toUpperCase();
+        oldAttributes[semantic_conventions_1.SEMATTRS_HTTP_STATUS_CODE] = statusCode;
+        oldAttributes[AttributeNames_1.AttributeNames.HTTP_STATUS_TEXT] = (statusMessage || '').toUpperCase();
+    }
+    (0, exports.setAttributesFromHttpKind)(httpVersion, oldAttributes);
+    switch (semconvStability) {
+        case 1 /* STABLE */:
+            return stableAttributes;
+        case 2 /* OLD */:
+            return oldAttributes;
     }
-    (0, exports.setAttributesFromHttpKind)(httpVersion, attributes);
-    return attributes;
+    return Object.assign(oldAttributes, stableAttributes);
 };
 exports.getOutgoingRequestAttributesOnResponse = getOutgoingRequestAttributesOnResponse;
 /**
  * Returns outgoing request Metric attributes scoped to the response data
- * @param {SpanAttributes} spanAttributes the span attributes
+ * @param {Attributes} spanAttributes the span attributes
  */
 const getOutgoingRequestMetricAttributesOnResponse = (spanAttributes) => {
     const metricAttributes = {};
@@ -346,24 +364,162 @@ const getOutgoingRequestMetricAttributesOnResponse = (spanAttributes) => {
     return metricAttributes;
 };
 exports.getOutgoingRequestMetricAttributesOnResponse = getOutgoingRequestMetricAttributesOnResponse;
+function parseHostHeader(hostHeader, proto) {
+    const parts = hostHeader.split(':');
+    // no semicolon implies ipv4 dotted syntax or host name without port
+    // x.x.x.x
+    // example.com
+    if (parts.length === 1) {
+        if (proto === 'http') {
+            return { host: parts[0], port: '80' };
+        }
+        if (proto === 'https') {
+            return { host: parts[0], port: '443' };
+        }
+        return { host: parts[0] };
+    }
+    // single semicolon implies ipv4 dotted syntax or host name with port
+    // x.x.x.x:yyyy
+    // example.com:yyyy
+    if (parts.length === 2) {
+        return {
+            host: parts[0],
+            port: parts[1],
+        };
+    }
+    // more than 2 parts implies ipv6 syntax with multiple colons
+    // [x:x:x:x:x:x:x:x]
+    // [x:x:x:x:x:x:x:x]:yyyy
+    if (parts[0].startsWith('[')) {
+        if (parts[parts.length - 1].endsWith(']')) {
+            if (proto === 'http') {
+                return { host: hostHeader, port: '80' };
+            }
+            if (proto === 'https') {
+                return { host: hostHeader, port: '443' };
+            }
+        }
+        else if (parts[parts.length - 2].endsWith(']')) {
+            return {
+                host: parts.slice(0, -1).join(':'),
+                port: parts[parts.length - 1],
+            };
+        }
+    }
+    // if nothing above matches just return the host header
+    return { host: hostHeader };
+}
+/**
+ * Get server.address and port according to http semconv 1.27
+ * https://github.com/open-telemetry/semantic-conventions/blob/bf0a2c1134f206f034408b201dbec37960ed60ec/docs/http/http-spans.md#setting-serveraddress-and-serverport-attributes
+ */
+function getServerAddress(request, component) {
+    const forwardedHeader = request.headers['forwarded'];
+    if (forwardedHeader) {
+        for (const entry of forwardedParse(forwardedHeader)) {
+            if (entry.host) {
+                return parseHostHeader(entry.host, entry.proto);
+            }
+        }
+    }
+    const xForwardedHost = request.headers['x-forwarded-host'];
+    if (typeof xForwardedHost === 'string') {
+        if (typeof request.headers['x-forwarded-proto'] === 'string') {
+            return parseHostHeader(xForwardedHost, request.headers['x-forwarded-proto']);
+        }
+        if (Array.isArray(request.headers['x-forwarded-proto'])) {
+            return parseHostHeader(xForwardedHost, request.headers['x-forwarded-proto'][0]);
+        }
+        return parseHostHeader(xForwardedHost);
+    }
+    else if (Array.isArray(xForwardedHost) &&
+        typeof xForwardedHost[0] === 'string' &&
+        xForwardedHost[0].length > 0) {
+        if (typeof request.headers['x-forwarded-proto'] === 'string') {
+            return parseHostHeader(xForwardedHost[0], request.headers['x-forwarded-proto']);
+        }
+        if (Array.isArray(request.headers['x-forwarded-proto'])) {
+            return parseHostHeader(xForwardedHost[0], request.headers['x-forwarded-proto'][0]);
+        }
+        return parseHostHeader(xForwardedHost[0]);
+    }
+    const host = request.headers['host'];
+    if (typeof host === 'string' && host.length > 0) {
+        return parseHostHeader(host, component);
+    }
+    return null;
+}
+/**
+ * Get server.address and port according to http semconv 1.27
+ * https://github.com/open-telemetry/semantic-conventions/blob/bf0a2c1134f206f034408b201dbec37960ed60ec/docs/http/http-spans.md#setting-serveraddress-and-serverport-attributes
+ */
+function getRemoteClientAddress(request) {
+    const forwardedHeader = request.headers['forwarded'];
+    if (forwardedHeader) {
+        for (const entry of forwardedParse(forwardedHeader)) {
+            if (entry.for) {
+                return entry.for;
+            }
+        }
+    }
+    const xForwardedFor = request.headers['x-forwarded-for'];
+    if (typeof xForwardedFor === 'string') {
+        return xForwardedFor;
+    }
+    else if (Array.isArray(xForwardedFor)) {
+        return xForwardedFor[0];
+    }
+    const remote = request.socket.remoteAddress;
+    if (remote) {
+        return remote;
+    }
+    return null;
+}
+exports.getRemoteClientAddress = getRemoteClientAddress;
 /**
  * Returns incoming request attributes scoped to the request data
  * @param {IncomingMessage} request the request object
- * @param {{ component: string, serverName?: string, hookAttributes?: SpanAttributes }} options used to pass data needed to create attributes
+ * @param {{ component: string, serverName?: string, hookAttributes?: Attributes }} options used to pass data needed to create attributes
+ * @param {SemconvStability} semconvStability determines which semconv version to use
  */
 const getIncomingRequestAttributes = (request, options) => {
     const headers = request.headers;
     const userAgent = headers['user-agent'];
     const ips = headers['x-forwarded-for'];
-    const method = request.method || 'GET';
     const httpVersion = request.httpVersion;
     const requestUrl = request.url ? url.parse(request.url) : null;
     const host = (requestUrl === null || requestUrl === void 0 ? void 0 : requestUrl.host) || headers.host;
     const hostname = (requestUrl === null || requestUrl === void 0 ? void 0 : requestUrl.hostname) ||
         (host === null || host === void 0 ? void 0 : host.replace(/^(.*)(:[0-9]{1,5})/, '$1')) ||
         'localhost';
+    const method = request.method;
+    const normalizedMethod = normalizeMethod(method);
+    const serverAddress = getServerAddress(request, options.component);
     const serverName = options.serverName;
-    const attributes = {
+    const remoteClientAddress = getRemoteClientAddress(request);
+    const newAttributes = {
+        [semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD]: normalizedMethod,
+        [semantic_conventions_1.ATTR_URL_SCHEME]: options.component,
+        [semantic_conventions_1.ATTR_SERVER_ADDRESS]: serverAddress === null || serverAddress === void 0 ? void 0 : serverAddress.host,
+        [semantic_conventions_1.ATTR_NETWORK_PEER_ADDRESS]: request.socket.remoteAddress,
+        [semantic_conventions_1.ATTR_NETWORK_PEER_PORT]: request.socket.remotePort,
+        [semantic_conventions_1.ATTR_NETWORK_PROTOCOL_VERSION]: request.httpVersion,
+        [semantic_conventions_1.ATTR_USER_AGENT_ORIGINAL]: userAgent,
+    };
+    if ((requestUrl === null || requestUrl === void 0 ? void 0 : requestUrl.pathname) != null) {
+        newAttributes[semantic_conventions_1.ATTR_URL_PATH] = requestUrl.pathname;
+    }
+    if (remoteClientAddress != null) {
+        newAttributes[semantic_conventions_1.ATTR_CLIENT_ADDRESS] = remoteClientAddress;
+    }
+    if ((serverAddress === null || serverAddress === void 0 ? void 0 : serverAddress.port) != null) {
+        newAttributes[semantic_conventions_1.ATTR_SERVER_PORT] = Number(serverAddress.port);
+    }
+    // conditionally required if request method required case normalization
+    if (method !== normalizedMethod) {
+        newAttributes[semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD_ORIGINAL] = method;
+    }
+    const oldAttributes = {
         [semantic_conventions_1.SEMATTRS_HTTP_URL]: (0, exports.getAbsoluteUrl)(requestUrl, headers, `${options.component}:`),
         [semantic_conventions_1.SEMATTRS_HTTP_HOST]: host,
         [semantic_conventions_1.SEMATTRS_NET_HOST_NAME]: hostname,
@@ -371,25 +527,31 @@ const getIncomingRequestAttributes = (request, options) => {
         [semantic_conventions_1.SEMATTRS_HTTP_SCHEME]: options.component,
     };
     if (typeof ips === 'string') {
-        attributes[semantic_conventions_1.SEMATTRS_HTTP_CLIENT_IP] = ips.split(',')[0];
+        oldAttributes[semantic_conventions_1.SEMATTRS_HTTP_CLIENT_IP] = ips.split(',')[0];
     }
     if (typeof serverName === 'string') {
-        attributes[semantic_conventions_1.SEMATTRS_HTTP_SERVER_NAME] = serverName;
+        oldAttributes[semantic_conventions_1.SEMATTRS_HTTP_SERVER_NAME] = serverName;
     }
     if (requestUrl) {
-        attributes[semantic_conventions_1.SEMATTRS_HTTP_TARGET] = requestUrl.path || '/';
+        oldAttributes[semantic_conventions_1.SEMATTRS_HTTP_TARGET] = requestUrl.path || '/';
     }
     if (userAgent !== undefined) {
-        attributes[semantic_conventions_1.SEMATTRS_HTTP_USER_AGENT] = userAgent;
+        oldAttributes[semantic_conventions_1.SEMATTRS_HTTP_USER_AGENT] = userAgent;
+    }
+    (0, exports.setRequestContentLengthAttribute)(request, oldAttributes);
+    (0, exports.setAttributesFromHttpKind)(httpVersion, oldAttributes);
+    switch (options.semconvStability) {
+        case 1 /* STABLE */:
+            return Object.assign(newAttributes, options.hookAttributes);
+        case 2 /* OLD */:
+            return Object.assign(oldAttributes, options.hookAttributes);
     }
-    (0, exports.setRequestContentLengthAttribute)(request, attributes);
-    (0, exports.setAttributesFromHttpKind)(httpVersion, attributes);
-    return Object.assign(attributes, options.hookAttributes);
+    return Object.assign(oldAttributes, newAttributes, options.hookAttributes);
 };
 exports.getIncomingRequestAttributes = getIncomingRequestAttributes;
 /**
  * Returns incoming request Metric attributes scoped to the request data
- * @param {SpanAttributes} spanAttributes the span attributes
+ * @param {Attributes} spanAttributes the span attributes
  * @param {{ component: string }} options used to pass data needed to create attributes
  */
 const getIncomingRequestMetricAttributes = (spanAttributes) => {
@@ -407,31 +569,41 @@ exports.getIncomingRequestMetricAttributes = getIncomingRequestMetricAttributes;
  * Returns incoming request attributes scoped to the response data
  * @param {(ServerResponse & { socket: Socket; })} response the response object
  */
-const getIncomingRequestAttributesOnResponse = (request, response) => {
+const getIncomingRequestAttributesOnResponse = (request, response, semconvStability) => {
     // take socket from the request,
     // since it may be detached from the response object in keep-alive mode
     const { socket } = request;
     const { statusCode, statusMessage } = response;
+    const newAttributes = {
+        [semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE]: statusCode,
+    };
     const rpcMetadata = (0, core_1.getRPCMetadata)(api_1.context.active());
-    const attributes = {};
+    const oldAttributes = {};
     if (socket) {
         const { localAddress, localPort, remoteAddress, remotePort } = socket;
-        attributes[semantic_conventions_1.SEMATTRS_NET_HOST_IP] = localAddress;
-        attributes[semantic_conventions_1.SEMATTRS_NET_HOST_PORT] = localPort;
-        attributes[semantic_conventions_1.SEMATTRS_NET_PEER_IP] = remoteAddress;
-        attributes[semantic_conventions_1.SEMATTRS_NET_PEER_PORT] = remotePort;
+        oldAttributes[semantic_conventions_1.SEMATTRS_NET_HOST_IP] = localAddress;
+        oldAttributes[semantic_conventions_1.SEMATTRS_NET_HOST_PORT] = localPort;
+        oldAttributes[semantic_conventions_1.SEMATTRS_NET_PEER_IP] = remoteAddress;
+        oldAttributes[semantic_conventions_1.SEMATTRS_NET_PEER_PORT] = remotePort;
     }
-    attributes[semantic_conventions_1.SEMATTRS_HTTP_STATUS_CODE] = statusCode;
-    attributes[AttributeNames_1.AttributeNames.HTTP_STATUS_TEXT] = (statusMessage || '').toUpperCase();
+    oldAttributes[semantic_conventions_1.SEMATTRS_HTTP_STATUS_CODE] = statusCode;
+    oldAttributes[AttributeNames_1.AttributeNames.HTTP_STATUS_TEXT] = (statusMessage || '').toUpperCase();
     if ((rpcMetadata === null || rpcMetadata === void 0 ? void 0 : rpcMetadata.type) === core_1.RPCType.HTTP && rpcMetadata.route !== undefined) {
-        attributes[semantic_conventions_1.SEMATTRS_HTTP_ROUTE] = rpcMetadata.route;
+        oldAttributes[semantic_conventions_1.SEMATTRS_HTTP_ROUTE] = rpcMetadata.route;
+        newAttributes[semantic_conventions_1.ATTR_HTTP_ROUTE] = rpcMetadata.route;
+    }
+    switch (semconvStability) {
+        case 1 /* STABLE */:
+            return newAttributes;
+        case 2 /* OLD */:
+            return oldAttributes;
     }
-    return attributes;
+    return Object.assign(oldAttributes, newAttributes);
 };
 exports.getIncomingRequestAttributesOnResponse = getIncomingRequestAttributesOnResponse;
 /**
  * Returns incoming request Metric attributes scoped to the request data
- * @param {SpanAttributes} spanAttributes the span attributes
+ * @param {Attributes} spanAttributes the span attributes
  */
 const getIncomingRequestMetricAttributesOnResponse = (spanAttributes) => {
     const metricAttributes = {};
@@ -445,6 +617,19 @@ const getIncomingRequestMetricAttributesOnResponse = (spanAttributes) => {
     return metricAttributes;
 };
 exports.getIncomingRequestMetricAttributesOnResponse = getIncomingRequestMetricAttributesOnResponse;
+const getIncomingStableRequestMetricAttributesOnResponse = (spanAttributes) => {
+    const metricAttributes = {};
+    if (spanAttributes[semantic_conventions_1.ATTR_HTTP_ROUTE] !== undefined) {
+        metricAttributes[semantic_conventions_1.ATTR_HTTP_ROUTE] = spanAttributes[semantic_conventions_1.SEMATTRS_HTTP_ROUTE];
+    }
+    // required if and only if one was sent, same as span requirement
+    if (spanAttributes[semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE]) {
+        metricAttributes[semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE] =
+            spanAttributes[semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE];
+    }
+    return metricAttributes;
+};
+exports.getIncomingStableRequestMetricAttributesOnResponse = getIncomingStableRequestMetricAttributesOnResponse;
 function headerCapture(type, headers) {
     const normalizedHeaders = new Map();
     for (let i = 0, len = headers.length; i < len; i++) {
@@ -472,4 +657,27 @@ function headerCapture(type, headers) {
     };
 }
 exports.headerCapture = headerCapture;
+const KNOWN_METHODS = new Set([
+    // methods from https://www.rfc-editor.org/rfc/rfc9110.html#name-methods
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'DELETE',
+    'CONNECT',
+    'OPTIONS',
+    'TRACE',
+    // PATCH from https://www.rfc-editor.org/rfc/rfc5789.html
+    'PATCH',
+]);
+function normalizeMethod(method) {
+    if (method == null) {
+        return 'GET';
+    }
+    const upper = method.toUpperCase();
+    if (KNOWN_METHODS.has(upper)) {
+        return upper;
+    }
+    return '_OTHER';
+}
 //# sourceMappingURL=utils.js.map