Merge branch 'main' into feat/span-dropped-counts

Author: mohitk05

CHANGELOG.md

@@ -19,7 +19,8 @@ For experimental package changes, see the [experimental CHANGELOG](experimental/
 * perf(propagator-jaeger): improve deserializeSpanContext performance [#3541](https://github.com/open-telemetry/opentelemetry-js/pull/3541) @doochik
 * feat: support TraceState in SamplingResult [#3530](https://github.com/open-telemetry/opentelemetry-js/pull/3530) @raphael-theriault-swi
 * feat(sdk-trace-base): add diagnostic logging when spans are dropped [#3610](https://github.com/open-telemetry/opentelemetry-js/pull/3610) @neoeinstein
-* feat(sdk-trace-base): expose dropped counts for attributes, events and links on span [#3576](https://github.com/open-telemetry/opentelemetry-js/pull/3576)
+* feat: add unit to view instrument selection criteria [#3647](https://github.com/open-telemetry/opentelemetry-js/pull/3647) @jlabatut
+* feat(sdk-trace-base): expose dropped counts for attributes, events and links on span [#3576](https://github.com/open-telemetry/opentelemetry-js/pull/3576) @mohitk05
 
 ### :bug: (Bug Fix)
 
@@ -32,6 +33,7 @@ For experimental package changes, see the [experimental CHANGELOG](experimental/
 
 ### :house: (Internal)
 
+* chore(exporter-jaeger): deprecate jaeger exporter [#3585](https://github.com/open-telemetry/opentelemetry-js/pull/3585) @pichlermarc
 * fix(sdk-metrics): fix flaky LastValueAggregator test by using fake timer [#3587](https://github.com/open-telemetry/opentelemetry-js/pull/3587) @pichlermarc
 * fix(test): fix failing tests by preventing source-map generation [#3642](https://github.com/open-telemetry/opentelemetry-js/pull/3642) @pichlermarc
 

packages/opentelemetry-exporter-jaeger/README.md

@@ -1,8 +1,14 @@
-# OpenTelemetry Jaeger Trace Exporter for Node.js
+# (Deprecated) OpenTelemetry Jaeger Trace Exporter for Node.js
 
 [![NPM Published Version][npm-img]][npm-url]
 [![Apache License][license-image]][license-image]
 
+**NOTE: Support for `@opentelemetry/exporter-jaeger` will end March 2024, please use any of the following packages instead:**
+
+- `@opentelemetry/exporter-trace-otlp-proto`
+- `@opentelemetry/exporter-trace-otlp-grpc`
+- `@opentelemetry/exporter-trace-otlp-http`
+
 OpenTelemetry Jaeger Trace Exporter allows the user to send collected traces to Jaeger.
 
 [Jaeger](https://jaeger.readthedocs.io/en/latest/), inspired by [Dapper](https://research.google.com/pubs/pub36356.html) and [OpenZipkin](http://zipkin.io/), is a distributed tracing system released as open source by [Uber Technologies](http://uber.github.io/). It is used for monitoring and troubleshooting microservices-based distributed systems, including:

packages/opentelemetry-exporter-jaeger/src/jaeger.ts

@@ -29,6 +29,16 @@ import * as jaegerTypes from './types';
 
 /**
  * Format and sends span information to Jaeger Exporter.
+ *
+ * @deprecated Jaeger supports the OpenTelemetry protocol natively
+ * (see https://www.jaegertracing.io/docs/1.41/apis/#opentelemetry-protocol-stable).
+ * This exporter will not be required by the OpenTelemetry specification starting July 2023, and
+ * will not receive any security fixes past March 2024.
+ *
+ * Please migrate to any of the following packages:
+ * - `@opentelemetry/exporter-trace-otlp-proto`
+ * - `@opentelemetry/exporter-trace-otlp-grpc`
+ * - `@opentelemetry/exporter-trace-otlp-http`
  */
 export class JaegerExporter implements SpanExporter {
   private readonly _onShutdownFlushTimeout: number;

packages/sdk-metrics/src/view/InstrumentSelector.ts

@@ -15,20 +15,23 @@
  */
 
 import { InstrumentType } from '../InstrumentDescriptor';
-import { PatternPredicate, Predicate } from './Predicate';
+import { ExactPredicate, PatternPredicate, Predicate } from './Predicate';
 
 export interface InstrumentSelectorCriteria {
   name?: string;
   type?: InstrumentType;
+  unit?: string;
 }
 
 export class InstrumentSelector {
   private _nameFilter: Predicate;
   private _type?: InstrumentType;
+  private _unitFilter: Predicate;
 
   constructor(criteria?: InstrumentSelectorCriteria) {
     this._nameFilter = new PatternPredicate(criteria?.name ?? '*');
     this._type = criteria?.type;
+    this._unitFilter = new ExactPredicate(criteria?.unit);
   }
 
   getType() {
@@ -38,4 +41,8 @@ export class InstrumentSelector {
   getNameFilter() {
     return this._nameFilter;
   }
+
+  getUnitFilter() {
+    return this._unitFilter;
+  }
 }

packages/sdk-metrics/src/view/RegistrationConflicts.ts

@@ -59,6 +59,7 @@ export function getTypeConflictResolutionRecipe(
   const selector: InstrumentSelectorCriteria = {
     name: otherDescriptor.name,
     type: otherDescriptor.type,
+    unit: otherDescriptor.unit,
   };
 
   const selectorString = JSON.stringify(selector);
@@ -73,6 +74,7 @@ export function getDescriptionResolutionRecipe(
   const selector: InstrumentSelectorCriteria = {
     name: otherDescriptor.name,
     type: otherDescriptor.type,
+    unit: otherDescriptor.unit,
   };
 
   const selectorString = JSON.stringify(selector);

packages/sdk-metrics/src/view/View.ts

@@ -83,6 +83,14 @@ export type ViewOptions = {
    * instrumentName: 'my.instruments.requests'
    */
   instrumentName?: string;
+  /**
+   * Instrument selection criteria:
+   * The unit of the Instrument(s).
+   *
+   * @example <caption>select all instruments with unit 'ms'</caption>
+   * instrumentUnit: 'ms'
+   */
+  instrumentUnit?: string;
   /**
    * Instrument selection criteria:
    * The name of the Meter. No wildcard support, name must match the meter exactly.
@@ -113,6 +121,7 @@ function isSelectorNotProvided(options: ViewOptions): boolean {
   return (
     options.instrumentName == null &&
     options.instrumentType == null &&
+    options.instrumentUnit == null &&
     options.meterName == null &&
     options.meterVersion == null &&
     options.meterSchemaUrl == null
@@ -161,6 +170,9 @@ export class View {
    * @param viewOptions.instrumentType
    * Instrument selection criteria:
    *  The original type of the Instrument(s).
+   * @param viewOptions.instrumentUnit
+   * Instrument selection criteria:
+   *  The unit of the Instrument(s).
    * @param viewOptions.meterName
    * Instrument selection criteria:
    *  The name of the Meter. No wildcard support, name must match the meter exactly.
@@ -213,6 +225,7 @@ export class View {
     this.instrumentSelector = new InstrumentSelector({
       name: viewOptions.instrumentName,
       type: viewOptions.instrumentType,
+      unit: viewOptions.instrumentUnit,
     });
     this.meterSelector = new MeterSelector({
       name: viewOptions.meterName,

packages/sdk-metrics/src/view/ViewRegistry.ts

@@ -48,7 +48,8 @@ export class ViewRegistry {
     return (
       (selector.getType() === undefined ||
         instrument.type === selector.getType()) &&
-      selector.getNameFilter().match(instrument.name)
+      selector.getNameFilter().match(instrument.name) &&
+      selector.getUnitFilter().match(instrument.unit)
     );
   }
 

packages/sdk-metrics/test/MeterProvider.test.ts

@@ -15,7 +15,13 @@
  */
 
 import * as assert from 'assert';
-import { MeterProvider, InstrumentType, DataPointType } from '../src';
+import {
+  MeterProvider,
+  InstrumentType,
+  DataPointType,
+  ExplicitBucketHistogramAggregation,
+  HistogramMetricData,
+} from '../src';
 import {
   assertScopeMetrics,
   assertMetricData,
@@ -463,6 +469,70 @@ describe('MeterProvider', () => {
         }
       );
     });
+
+    it('with instrument unit should apply view to only the selected instrument unit', async () => {
+      // Add views with different boundaries for each unit.
+      const msBoundaries = [0, 1, 2, 3, 4, 5];
+      const sBoundaries = [10, 50, 250, 1000];
+
+      const meterProvider = new MeterProvider({
+        resource: defaultResource,
+        views: [
+          new View({
+            instrumentUnit: 'ms',
+            aggregation: new ExplicitBucketHistogramAggregation(msBoundaries),
+          }),
+          new View({
+            instrumentUnit: 's',
+            aggregation: new ExplicitBucketHistogramAggregation(sBoundaries),
+          }),
+        ],
+      });
+
+      const reader = new TestMetricReader();
+      meterProvider.addMetricReader(reader);
+
+      // Create meter and histograms, with different units.
+      const meter = meterProvider.getMeter('meter1', 'v1.0.0');
+      const histogram1 = meter.createHistogram('test-histogram-ms', {
+        unit: 'ms',
+      });
+      const histogram2 = meter.createHistogram('test-histogram-s', {
+        unit: 's',
+      });
+
+      // Record values for both.
+      histogram1.record(1);
+      histogram2.record(1);
+
+      // Perform collection.
+      const { resourceMetrics, errors } = await reader.collect();
+
+      assert.strictEqual(errors.length, 0);
+      // Results came only from one Meter
+      assert.strictEqual(resourceMetrics.scopeMetrics.length, 1);
+
+      // InstrumentationScope matches the only created Meter.
+      assertScopeMetrics(resourceMetrics.scopeMetrics[0], {
+        name: 'meter1',
+        version: 'v1.0.0',
+      });
+
+      // Two metrics are collected ('test-histogram-ms' and 'test-histogram-s')
+      assert.strictEqual(resourceMetrics.scopeMetrics[0].metrics.length, 2);
+
+      // Check if the boundaries are applied to the correct instrument.
+      assert.deepStrictEqual(
+        (resourceMetrics.scopeMetrics[0].metrics[0] as HistogramMetricData)
+          .dataPoints[0].value.buckets.boundaries,
+        msBoundaries
+      );
+      assert.deepStrictEqual(
+        (resourceMetrics.scopeMetrics[0].metrics[1] as HistogramMetricData)
+          .dataPoints[0].value.buckets.boundaries,
+        sBoundaries
+      );
+    });
   });
 
   describe('shutdown', () => {

packages/sdk-metrics/test/view/ViewRegistry.test.ts

@@ -101,6 +101,50 @@ describe('ViewRegistry', () => {
           assert.strictEqual(views[0].name, 'histogram');
         }
       });
+
+      it('should match view with instrument unit', () => {
+        const registry = new ViewRegistry();
+        registry.addView(
+          new View({
+            name: 'ms_view',
+            instrumentName: 'default_metric',
+            instrumentUnit: 'ms',
+          })
+        );
+        registry.addView(
+          new View({
+            name: 's_view',
+            instrumentName: 'default_metric',
+            instrumentUnit: 's',
+          })
+        );
+
+        {
+          const views = registry.findViews(
+            {
+              ...defaultInstrumentDescriptor,
+              unit: 'ms',
+            },
+            defaultInstrumentationScope
+          );
+
+          assert.strictEqual(views.length, 1);
+          assert.strictEqual(views[0].name, 'ms_view');
+        }
+
+        {
+          const views = registry.findViews(
+            {
+              ...defaultInstrumentDescriptor,
+              unit: 's',
+            },
+            defaultInstrumentationScope
+          );
+
+          assert.strictEqual(views.length, 1);
+          assert.strictEqual(views[0].name, 's_view');
+        }
+      });
     });
 
     describe('MeterSelector', () => {

scripts/update-ts-configs.js

@@ -50,6 +50,7 @@ const ignoredLernaProjects = [
   'selenium-tests',
   'examples/otlp-exporter-node',
   'examples/opentelemetry-web',
+  'examples/http',
   'examples/https',
 ];