Merge branch 'main' into http-attr-sampling

packages/opentelemetry-instrumentation/src/platform/node/instrumentation.ts

@@ -17,7 +17,7 @@
 import * as types from '../../types';
 import * as path from 'path';
 import * as RequireInTheMiddle from 'require-in-the-middle';
-import * as semver from 'semver';
+import { satisfies } from 'semver';
 import { InstrumentationAbstract } from '../../instrumentation';
 import { InstrumentationModuleDefinition } from './types';
 import { diag } from '@opentelemetry/api';
@@ -50,7 +50,7 @@ export abstract class InstrumentationBase<T = any>
     if (this._modules.length === 0) {
       diag.warn(
         'No modules instrumentation has been defined,' +
-          ' nothing will be patched'
+        ' nothing will be patched'
       );
     }
 
@@ -80,7 +80,7 @@ export abstract class InstrumentationBase<T = any>
       // main module
       if (
         typeof version === 'string' &&
-        isSupported(module.supportedVersions, version)
+        isSupported(module.supportedVersions, version, module.includePrerelease)
       ) {
         if (typeof module.patch === 'function') {
           module.moduleExports = exports;
@@ -93,7 +93,7 @@ export abstract class InstrumentationBase<T = any>
       // internal file
       const files = module.files ?? [];
       const file = files.find(file => file.name === name);
-      if (file && isSupported(file.supportedVersions, version)) {
+      if (file && isSupported(file.supportedVersions, version, module.includePrerelease)) {
         file.moduleExports = exports;
         if (this._enabled) {
           return file.patch(exports, module.moduleVersion);
@@ -167,8 +167,8 @@ export abstract class InstrumentationBase<T = any>
   }
 }
 
-function isSupported(supportedVersions: string[], version: string): boolean {
+function isSupported(supportedVersions: string[], version: string, includePrerelease?: boolean): boolean {
   return supportedVersions.some(supportedVersion => {
-    return semver.satisfies(version, supportedVersion);
+    return satisfies(version, supportedVersion, { includePrerelease });
   });
 }

packages/opentelemetry-instrumentation/src/platform/node/types.ts

@@ -47,6 +47,9 @@ export interface InstrumentationModuleDefinition<T> {
   /** Module internal files to be patched  */
   files: InstrumentationModuleFile<any>[];
 
+  /** If set to true, the includePrerelease check will be included when calling semver.satisfies */
+  includePrerelease?: boolean;
+
   /** Method to patch the instrumentation  */
   patch?: (moduleExports: T, moduleVersion?: string) => T;
 

packages/opentelemetry-web/src/enums/PerformanceTimingNames.ts

@@ -17,6 +17,7 @@
 export enum PerformanceTimingNames {
   CONNECT_END = 'connectEnd',
   CONNECT_START = 'connectStart',
+  DECODED_BODY_SIZE = 'decodedBodySize',
   DOM_COMPLETE = 'domComplete',
   DOM_CONTENT_LOADED_EVENT_END = 'domContentLoadedEventEnd',
   DOM_CONTENT_LOADED_EVENT_START = 'domContentLoadedEventStart',

packages/opentelemetry-web/src/types.ts

@@ -18,6 +18,7 @@ import { PerformanceTimingNames } from './enums/PerformanceTimingNames';
 export type PerformanceEntries = {
   [PerformanceTimingNames.CONNECT_END]?: number;
   [PerformanceTimingNames.CONNECT_START]?: number;
+  [PerformanceTimingNames.DECODED_BODY_SIZE]?: number;
   [PerformanceTimingNames.DOM_COMPLETE]?: number;
   [PerformanceTimingNames.DOM_CONTENT_LOADED_EVENT_END]?: number;
   [PerformanceTimingNames.DOM_CONTENT_LOADED_EVENT_START]?: number;

packages/opentelemetry-web/src/utils.ts

@@ -87,11 +87,19 @@ export function addSpanNetworkEvents(
   addSpanNetworkEvent(span, PTN.REQUEST_START, resource);
   addSpanNetworkEvent(span, PTN.RESPONSE_START, resource);
   addSpanNetworkEvent(span, PTN.RESPONSE_END, resource);
-  const contentLength = resource[PTN.ENCODED_BODY_SIZE];
-  if (contentLength !== undefined) {
+  const encodedLength = resource[PTN.ENCODED_BODY_SIZE];
+  if (encodedLength !== undefined) {
     span.setAttribute(
       SemanticAttributes.HTTP_RESPONSE_CONTENT_LENGTH,
-      contentLength
+      encodedLength
+    );
+  }
+  const decodedLength = resource[PTN.DECODED_BODY_SIZE];
+  // Spec: Not set if transport encoding not used (in which case encoded and decoded sizes match)
+  if (decodedLength !== undefined && encodedLength !== decodedLength) {
+    span.setAttribute(
+      SemanticAttributes.HTTP_RESPONSE_CONTENT_LENGTH_UNCOMPRESSED,
+      decodedLength
     );
   }
 }

packages/opentelemetry-web/test/utils.test.ts

@@ -146,14 +146,34 @@ describe('utils', () => {
         [PTN.REQUEST_START]: 123,
         [PTN.RESPONSE_START]: 123,
         [PTN.RESPONSE_END]: 123,
-        [PTN.ENCODED_BODY_SIZE]: 123,
+        [PTN.DECODED_BODY_SIZE]: 123,
+        [PTN.ENCODED_BODY_SIZE]: 61,
       } as PerformanceEntries;
 
       assert.strictEqual(addEventSpy.callCount, 0);
 
       addSpanNetworkEvents(span, entries);
 
       assert.strictEqual(addEventSpy.callCount, 9);
+      assert.strictEqual(setAttributeSpy.callCount, 2);
+    });
+    it('should only include encoded size when content encoding is being used', () => {
+      const addEventSpy = sinon.spy();
+      const setAttributeSpy = sinon.spy();
+      const span = ({
+        addEvent: addEventSpy,
+        setAttribute: setAttributeSpy,
+      } as unknown) as tracing.Span;
+      const entries = {
+        [PTN.DECODED_BODY_SIZE]: 123,
+        [PTN.ENCODED_BODY_SIZE]: 123,
+      } as PerformanceEntries;
+
+      assert.strictEqual(setAttributeSpy.callCount, 0);
+
+      addSpanNetworkEvents(span, entries);
+
+      assert.strictEqual(addEventSpy.callCount, 0);
       assert.strictEqual(setAttributeSpy.callCount, 1);
     });
   });

renovate.json

@@ -11,8 +11,8 @@
       "rangeStrategy": "bump"
     },
     {
-      "matchPaths": ["backwards-compatibility/**"],
-      "ignoreDeps": ["@types/node"],
+      "matchPaths": ["backwards-compatibility"],
+      "matchPackageNames": ["@types/node"],
       "enabled": false
     }
   ],