fix(sdk-trace-base): fix spanLimits attribute length/count to consider env values

CHANGELOG.md

@@ -12,6 +12,7 @@ All notable changes to this project will be documented in this file.
 
 * fix(resources): fix browser compatibility for host and os detectors [#3004](https://github.com/open-telemetry/opentelemetry-js/pull/3004) @legendecas
 * fix(sdk-trace-base): fix crash on environments without global document [#3000](https://github.com/open-telemetry/opentelemetry-js/pull/3000) @legendecas
+* chore(sdk-trace-base): fix spanLimits attribute length/count to consider env values [#3068](https://github.com/open-telemetry/opentelemetry-js/pull/3068) @svetlanabrennan
 
 ### :books: (Refine Doc)
 

packages/opentelemetry-sdk-trace-base/src/BasicTracerProvider.ts

@@ -31,7 +31,7 @@ import {
 } from '@opentelemetry/core';
 import { Resource } from '@opentelemetry/resources';
 import { SpanProcessor, Tracer } from '.';
-import { DEFAULT_CONFIG } from './config';
+import { loadDefaultConfig } from './config';
 import { MultiSpanProcessor } from './MultiSpanProcessor';
 import { NoopSpanProcessor } from './export/NoopSpanProcessor';
 import { SDKRegistrationConfig, TracerConfig } from './types';
@@ -74,7 +74,7 @@ export class BasicTracerProvider implements TracerProvider {
   readonly resource: Resource;
 
   constructor(config: TracerConfig = {}) {
-    const mergedConfig = merge({}, DEFAULT_CONFIG, reconfigureLimits(config));
+    const mergedConfig = merge({}, loadDefaultConfig(), reconfigureLimits(config));
     this.resource = mergedConfig.resource ?? Resource.empty();
     this.resource = Resource.default().merge(this.resource);
     this._config = Object.assign({}, mergedConfig, {

packages/opentelemetry-sdk-trace-base/src/config.ts

@@ -30,25 +30,30 @@ const FALLBACK_OTEL_TRACES_SAMPLER = TracesSamplerValues.AlwaysOn;
 const DEFAULT_RATIO = 1;
 
 /**
- * Default configuration. For fields with primitive values, any user-provided
+ * Load default configuration. For fields with primitive values, any user-provided
  * value will override the corresponding default value. For fields with
  * non-primitive values (like `spanLimits`), the user-provided value will be
  * used to extend the default value.
  */
-export const DEFAULT_CONFIG = {
-  sampler: buildSamplerFromEnv(env),
-  forceFlushTimeoutMillis: 30000,
-  generalLimits: {
-    attributeValueLengthLimit: getEnv().OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT,
-    attributeCountLimit: getEnv().OTEL_ATTRIBUTE_COUNT_LIMIT,
-  },
-  spanLimits: {
-    attributeValueLengthLimit: getEnv().OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT,
-    attributeCountLimit: getEnv().OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT,
-    linkCountLimit: getEnv().OTEL_SPAN_LINK_COUNT_LIMIT,
-    eventCountLimit: getEnv().OTEL_SPAN_EVENT_COUNT_LIMIT,
-  },
-};
+
+// object needs to be wrapped in this function and called when needed otherwise
+// envs are parsed before tests are ran - causes tests using these envs to fail
+export function loadDefaultConfig() {
+  return {
+    sampler: buildSamplerFromEnv(env),
+    forceFlushTimeoutMillis: 30000,
+    generalLimits: {
+      attributeValueLengthLimit: getEnv().OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT,
+      attributeCountLimit: getEnv().OTEL_ATTRIBUTE_COUNT_LIMIT,
+    },
+    spanLimits: {
+      attributeValueLengthLimit: getEnv().OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT,
+      attributeCountLimit: getEnv().OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT,
+      linkCountLimit: getEnv().OTEL_SPAN_LINK_COUNT_LIMIT,
+      eventCountLimit: getEnv().OTEL_SPAN_EVENT_COUNT_LIMIT,
+    },
+  };
+}
 
 /**
  * Based on environment, builds a sampler, complies with specification.

packages/opentelemetry-sdk-trace-base/src/utility.ts

@@ -15,8 +15,12 @@
  */
 
 import { Sampler } from '@opentelemetry/api';
-import { buildSamplerFromEnv, DEFAULT_CONFIG } from './config';
+import { buildSamplerFromEnv, loadDefaultConfig } from './config';
 import { SpanLimits, TracerConfig, GeneralLimits } from './types';
+import {
+  DEFAULT_ATTRIBUTE_COUNT_LIMIT,
+  DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT
+} from '@opentelemetry/core';
 
 /**
  * Function to merge Default configuration (as specified in './config') with
@@ -31,6 +35,8 @@ export function mergeConfig(userConfig: TracerConfig): TracerConfig & {
     sampler: buildSamplerFromEnv(),
   };
 
+  const DEFAULT_CONFIG = loadDefaultConfig();
+
   const target = Object.assign(
     {},
     DEFAULT_CONFIG,
@@ -61,20 +67,44 @@ export function mergeConfig(userConfig: TracerConfig): TracerConfig & {
 export function reconfigureLimits(userConfig: TracerConfig): TracerConfig {
   const spanLimits = Object.assign({}, userConfig.spanLimits);
 
+  const DEFAULT_CONFIG = loadDefaultConfig();
+
   /**
    * When span attribute count limit is not defined, but general attribute count limit is defined
    * Then, span attribute count limit will be same as general one
    */
-  if (spanLimits.attributeCountLimit == null && userConfig.generalLimits?.attributeCountLimit != null) {
-    spanLimits.attributeCountLimit = userConfig.generalLimits.attributeCountLimit;
+  if (
+    spanLimits.attributeCountLimit == null &&
+    (DEFAULT_CONFIG.spanLimits.attributeCountLimit === DEFAULT_ATTRIBUTE_COUNT_LIMIT) &&
+    (
+      userConfig.generalLimits?.attributeCountLimit != null ||
+      DEFAULT_CONFIG.generalLimits.attributeCountLimit !== DEFAULT_ATTRIBUTE_COUNT_LIMIT
+    )
+  ) {
+    const attributeCountLimit =
+     userConfig.generalLimits?.attributeCountLimit ??
+      DEFAULT_CONFIG.generalLimits.attributeCountLimit;
+
+    spanLimits.attributeCountLimit = attributeCountLimit;
   }
 
   /**
    * When span attribute value length limit is not defined, but general attribute value length limit is defined
    * Then, span attribute value length limit will be same as general one
    */
-  if (spanLimits.attributeValueLengthLimit == null && userConfig.generalLimits?.attributeValueLengthLimit != null) {
-    spanLimits.attributeValueLengthLimit = userConfig.generalLimits.attributeValueLengthLimit;
+  if (
+    spanLimits.attributeValueLengthLimit == null &&
+    (DEFAULT_CONFIG.spanLimits.attributeValueLengthLimit === DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT) &&
+    (
+      userConfig.generalLimits?.attributeValueLengthLimit != null ||
+      DEFAULT_CONFIG.generalLimits.attributeValueLengthLimit !== DEFAULT_ATTRIBUTE_VALUE_LENGTH_LIMIT
+    )
+  ) {
+    const attributeValueLengthLimit =
+      userConfig.generalLimits?.attributeValueLengthLimit ??
+        DEFAULT_CONFIG.generalLimits.attributeValueLengthLimit;
+
+    spanLimits.attributeValueLengthLimit = attributeValueLengthLimit;
   }
 
   return Object.assign({}, userConfig, { spanLimits });

packages/opentelemetry-sdk-trace-base/test/common/BasicTracerProvider.test.ts

@@ -182,6 +182,66 @@ describe('BasicTracerProvider', () => {
         });
       });
 
+      describe('when attribute value length limit is defined via env', () => {
+        it('should have general attribute value length limits value as defined with env', () => {
+          envSource.OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT = '115';
+          const tracer = new BasicTracerProvider().getTracer('default');
+          const generalLimits = tracer.getGeneralLimits();
+          assert.strictEqual(generalLimits.attributeValueLengthLimit, 115);
+          delete envSource.OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+        });
+        it('should have span attribute value length limits value same as general limit value', () => {
+          envSource.OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT = '125';
+          const tracer = new BasicTracerProvider().getTracer('default');
+          const generalLimits = tracer.getGeneralLimits();
+          const spanLimits = tracer.getSpanLimits();
+          assert.strictEqual(generalLimits.attributeValueLengthLimit, 125);
+          assert.strictEqual(spanLimits.attributeValueLengthLimit, 125);
+          delete envSource.OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+        });
+        it('should have span and general attribute value length limits as defined in env', () => {
+          envSource.OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT = '125';
+          envSource.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT = '109';
+          const tracer = new BasicTracerProvider().getTracer('default');
+          const spanLimits = tracer.getSpanLimits();
+          const generalLimits = tracer.getGeneralLimits();
+          assert.strictEqual(generalLimits.attributeValueLengthLimit, 125);
+          assert.strictEqual(spanLimits.attributeValueLengthLimit, 109);
+          delete envSource.OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+          delete envSource.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+        });
+      });
+
+      describe('when attribute count limit is defined via env', () => {
+        it('should general attribute count limit as defined with env', () => {
+          envSource.OTEL_ATTRIBUTE_COUNT_LIMIT = '25';
+          const tracer = new BasicTracerProvider({}).getTracer('default');
+          const generalLimits = tracer.getGeneralLimits();
+          assert.strictEqual(generalLimits.attributeCountLimit, 25);
+          delete envSource.OTEL_ATTRIBUTE_COUNT_LIMIT;
+        });
+        it('should have span attribute countlimits value same as general limit value', () => {
+          envSource.OTEL_ATTRIBUTE_COUNT_LIMIT = '20';
+          const tracer = new BasicTracerProvider().getTracer('default');
+          const generalLimits = tracer.getGeneralLimits();
+          const spanLimits = tracer.getSpanLimits();
+          assert.strictEqual(generalLimits.attributeCountLimit, 20);
+          assert.strictEqual(spanLimits.attributeCountLimit, 20);
+          delete envSource.OTEL_ATTRIBUTE_COUNT_LIMIT;
+        });
+        it('should have span and general attribute count limits as defined in env', () => {
+          envSource.OTEL_ATTRIBUTE_COUNT_LIMIT = '20';
+          envSource.OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT = '35';
+          const tracer = new BasicTracerProvider().getTracer('default');
+          const spanLimits = tracer.getSpanLimits();
+          const generalLimits = tracer.getGeneralLimits();
+          assert.strictEqual(generalLimits.attributeCountLimit, 20);
+          assert.strictEqual(spanLimits.attributeCountLimit, 35);
+          delete envSource.OTEL_ATTRIBUTE_COUNT_LIMIT;
+          delete envSource.OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT;
+        });
+      });
+
       describe('when "eventCountLimit" is defined', () => {
         it('should have tracer with defined value', () => {
           const tracer = new BasicTracerProvider({