feat(sdk-trace-base): add AlwaysRecordSampler

Author: majanjua-amzn

CHANGELOG.md

@@ -16,6 +16,7 @@ For notes on migrating to 2.x / 0.200.x see [the upgrade guide](doc/upgrade-to-2
 
 * feat(sdk-trace-base): implement on ending in span processor [#6024](https://github.com/open-telemetry/opentelemetry-js/pull/6024) @majanjua-amzn
   * note: this feature is experimental and subject to change
+* feat(sdk-trace-base): add AlwaysRecordSampler [#6168](https://github.com/open-telemetry/opentelemetry-js/pull/6168) @majanjua-amzn
 
 ### :bug: Bug Fixes
 

packages/opentelemetry-sdk-trace-base/src/sampler/AlwaysRecordSampler.ts

@@ -0,0 +1,85 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Includes work from:
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { Context, Link, Attributes, SpanKind } from '@opentelemetry/api';
+import { Sampler, SamplingDecision, SamplingResult } from '../Sampler';
+
+/**
+ * This sampler will return the sampling result of the provided {@link #rootSampler}, unless the
+ * sampling result contains the sampling decision {@link SamplingDecision.NOT_RECORD}, in which case, a
+ * new sampling result will be returned that is functionally equivalent to the original, except that
+ * it contains the sampling decision {@link SamplingDecision.RECORD}. This ensures that all
+ * spans are recorded, with no change to sampling.
+ *
+ * <p>The intended use case of this sampler is to provide a means of sending all spans to a
+ * processor without having an impact on the sampling rate. This may be desirable if a user wishes
+ * to count or otherwise measure all spans produced in a service, without incurring the cost of 100%
+ * sampling.
+ */
+export class AlwaysRecordSampler implements Sampler {
+  private rootSampler: Sampler;
+
+  public static create(rootSampler: Sampler): AlwaysRecordSampler {
+    return new AlwaysRecordSampler(rootSampler);
+  }
+
+  private constructor(rootSampler: Sampler) {
+    if (rootSampler == null) {
+      throw new Error('rootSampler is null/undefined. It must be provided');
+    }
+    this.rootSampler = rootSampler;
+  }
+
+  shouldSample(
+    context: Context,
+    traceId: string,
+    spanName: string,
+    spanKind: SpanKind,
+    attributes: Attributes,
+    links: Link[]
+  ): SamplingResult {
+    const rootSamplerSamplingResult: SamplingResult =
+      this.rootSampler.shouldSample(
+        context,
+        traceId,
+        spanName,
+        spanKind,
+        attributes,
+        links
+      );
+    if (rootSamplerSamplingResult.decision === SamplingDecision.NOT_RECORD) {
+      return this.wrapResultWithRecordOnlyResult(rootSamplerSamplingResult);
+    }
+    return rootSamplerSamplingResult;
+  }
+
+  toString(): string {
+    return `AlwaysRecordSampler{${this.rootSampler.toString()}}`;
+  }
+
+  wrapResultWithRecordOnlyResult(result: SamplingResult) {
+    const wrappedResult: SamplingResult = {
+      decision: SamplingDecision.RECORD,
+      attributes: result.attributes,
+      traceState: result.traceState,
+    };
+    return wrappedResult;
+  }
+}

packages/opentelemetry-sdk-trace-base/test/common/sampler/AlwaysRecordSampler.test.ts

@@ -0,0 +1,120 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Includes work from:
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import * as assert from 'assert';
+import {
+  Attributes,
+  SpanKind,
+  TraceState,
+  context,
+  createTraceState,
+} from '@opentelemetry/api';
+import {
+  RandomIdGenerator,
+  Sampler,
+  SamplingDecision,
+  SamplingResult,
+} from '../../../src';
+import { AlwaysOffSampler } from '../../../src/sampler/AlwaysOffSampler';
+import { AlwaysRecordSampler } from '../../../src/sampler/AlwaysRecordSampler';
+
+let mockedSampler: Sampler;
+let sampler: AlwaysRecordSampler;
+
+describe('AlwaysRecordSamplerTest', () => {
+  beforeEach(() => {
+    mockedSampler = new AlwaysOffSampler();
+    sampler = AlwaysRecordSampler.create(mockedSampler);
+  });
+
+  it('testGetDescription', () => {
+    mockedSampler.toString = () => 'mockDescription';
+    assert.strictEqual(
+      sampler.toString(),
+      'AlwaysRecordSampler{mockDescription}'
+    );
+  });
+
+  it('testRecordAndSampleSamplingDecision', () => {
+    validateShouldSample(
+      SamplingDecision.RECORD_AND_SAMPLED,
+      SamplingDecision.RECORD_AND_SAMPLED
+    );
+  });
+
+  it('testRecordOnlySamplingDecision', () => {
+    validateShouldSample(SamplingDecision.RECORD, SamplingDecision.RECORD);
+  });
+
+  it('testDropSamplingDecision', () => {
+    validateShouldSample(SamplingDecision.NOT_RECORD, SamplingDecision.RECORD);
+  });
+
+  it('testCreateAlwaysRecordSamplerThrows', () => {
+    assert.throws(() => AlwaysRecordSampler.create(null as unknown as Sampler));
+    assert.throws(() =>
+      AlwaysRecordSampler.create(undefined as unknown as Sampler)
+    );
+  });
+});
+
+function validateShouldSample(
+  rootDecision: SamplingDecision,
+  expectedDecision: SamplingDecision
+): void {
+  const rootResult: SamplingResult = buildRootSamplingResult(rootDecision);
+  mockedSampler.shouldSample = () => {
+    return rootResult;
+  };
+
+  const actualResult: SamplingResult = sampler.shouldSample(
+    context.active(),
+    new RandomIdGenerator().generateTraceId(),
+    'spanName',
+    SpanKind.CLIENT,
+    {},
+    []
+  );
+
+  if (rootDecision === expectedDecision) {
+    assert.strictEqual(actualResult, rootResult);
+    assert.strictEqual(actualResult.decision, rootDecision);
+  } else {
+    assert.notEqual(actualResult, rootResult);
+    assert.strictEqual(actualResult.decision, expectedDecision);
+  }
+
+  assert.strictEqual(actualResult.attributes, rootResult.attributes);
+  assert.strictEqual(actualResult.traceState, rootResult.traceState);
+}
+
+function buildRootSamplingResult(
+  samplingDecision: SamplingDecision
+): SamplingResult {
+  const samplingAttr: Attributes = { key: SamplingDecision[samplingDecision] };
+  const samplingTraceState: TraceState = createTraceState();
+  samplingTraceState.set('key', SamplingDecision[samplingDecision]);
+  const samplingResult: SamplingResult = {
+    decision: samplingDecision,
+    attributes: samplingAttr,
+    traceState: samplingTraceState,
+  };
+  return samplingResult;
+}