Add trace params (#311)

* Add Trace Parameters limits * Improve null checking, naming conventions..Address CR comments. * Fix Typos. * Improve null checking, naming conventions..Address CR comments. Fix Typos. * Import constants from TraceParamsBuilder * Add unit test for verifying max parameter values.Address CR comments
census-instrumentation · Jan 31, 2019 · f98ec08 · f98ec08
1 parent 2a13a77
commit f98ec08
Show file tree

Hide file tree

Showing 5 changed files with 157 additions and 4 deletions.
diff --git a/packages/opencensus-core/src/trace/config/types.ts b/packages/opencensus-core/src/trace/config/types.ts
@@ -37,6 +37,8 @@ export interface TracerConfig {
   logger?: Logger;
   /** A propagation instance */
   propagation?: Propagation;
+  /** Trace Parameters */
+  traceParams?: TraceParams;
 }
 
 /** Available configuration options. */
@@ -70,4 +72,19 @@ export interface TracingConfig {
   logger?: Logger;
 }
 
+/** Global configuration of trace service */
+export interface TraceParams {
+  /**
+   * numberOfAnnontationEventsPerSpan is number of annotation events per
+   * span
+   */
+  numberOfAnnontationEventsPerSpan?: number;
+  /** numberOfMessageEventsPerSpan is number of message events per span */
+  numberOfMessageEventsPerSpan?: number;
+  /** numberOfAttributesPerSpan is number of attributes per span */
+  numberOfAttributesPerSpan?: number;
+  /** numberOfLinksPerSpan is number of links per span */
+  numberOfLinksPerSpan?: number;
+}
+
 export type Config = TracingConfig&TracerConfig&BufferConfig;
diff --git a/packages/opencensus-core/src/trace/model/tracer.ts b/packages/opencensus-core/src/trace/model/tracer.ts
@@ -18,9 +18,12 @@ import * as logger from '../../common/console-logger';
 import * as loggerTypes from '../../common/types';
 import * as cls from '../../internal/cls';
 import * as configTypes from '../config/types';
+import {TraceParams} from '../config/types';
 import {Propagation} from '../propagation/types';
-import {SamplerBuilder} from '../sampler/sampler';
+import * as samplerConstants from '../sampler/sampler';
+import {SamplerBuilder, TraceParamsBuilder} from '../sampler/sampler';
 import * as samplerTypes from '../sampler/types';
+
 import {RootSpan} from './root-span';
 import * as types from './types';
 
@@ -42,11 +45,20 @@ export class CoreTracer implements types.Tracer {
   private endedTraces: types.RootSpan[] = [];
   /** Bit to represent whether trace is sampled or not. */
   private readonly IS_SAMPLED = 0x1;
+  private readonly DEFAULT_TRACE_PARAMS: TraceParams = {
+    numberOfAnnontationEventsPerSpan:
+        samplerConstants.DEFAULT_SPAN_MAX_NUM_ANNOTATIONS,
+    numberOfAttributesPerSpan: samplerConstants.DEFAULT_SPAN_MAX_NUM_ATTRIBUTES,
+    numberOfLinksPerSpan: samplerConstants.DEFAULT_SPAN_MAX_NUM_LINKS,
+    numberOfMessageEventsPerSpan: samplerConstants
+                                    .DEFAULT_SPAN_MAX_NUM_MESSAGE_EVENTS
+  };
   /** A sampler used to make sample decisions */
   sampler: samplerTypes.Sampler;
   /** A configuration for starting the tracer */
   logger: loggerTypes.Logger = logger.logger();
-
+  /** A configuration object for trace parameters */
+  activeTraceParams: TraceParams = this.DEFAULT_TRACE_PARAMS;
 
   /** Constructs a new TraceImpl instance. */
   constructor() {
@@ -81,6 +93,18 @@ export class CoreTracer implements types.Tracer {
     this.config = config;
     this.logger = this.config.logger || logger.logger();
     this.sampler = SamplerBuilder.getSampler(config.samplingRate);
+    if (config.traceParams) {
+      this.activeTraceParams.numberOfAnnontationEventsPerSpan =
+          TraceParamsBuilder.getNumberOfAnnotationEventsPerSpan(
+              config.traceParams);
+      this.activeTraceParams.numberOfAttributesPerSpan =
+          TraceParamsBuilder.getNumberOfAttributesPerSpan(config.traceParams);
+      this.activeTraceParams.numberOfMessageEventsPerSpan =
+          TraceParamsBuilder.getNumberOfMessageEventsPerSpan(
+              config.traceParams);
+      this.activeTraceParams.numberOfLinksPerSpan =
+          TraceParamsBuilder.getNumberOfLinksPerSpan(config.traceParams);
+    }
     return this;
   }
 

diff --git a/packages/opencensus-core/src/trace/sampler/sampler.ts b/packages/opencensus-core/src/trace/sampler/sampler.ts
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import {TraceParams} from '../config/types';
+
 import {Sampler} from './types';
 
 // We use 52-bits as our max number because it remains a javascript "safe
@@ -97,3 +99,44 @@ export class SamplerBuilder {
     return new ProbabilitySampler(probability);
   }
 }
+
+
+/** Default Limit for Annotations per span */
+export const DEFAULT_SPAN_MAX_NUM_ANNOTATIONS = 32;
+/** Default limit for Message events per span */
+export const DEFAULT_SPAN_MAX_NUM_MESSAGE_EVENTS = 128;
+/** Default limit for Attributes per span */
+export const DEFAULT_SPAN_MAX_NUM_ATTRIBUTES = 32;
+/** Default limit for Links per span */
+export const DEFAULT_SPAN_MAX_NUM_LINKS = 32;
+
+/** Builder Class of TraceParams */
+export class TraceParamsBuilder {
+  static getNumberOfAnnotationEventsPerSpan(traceParameters: TraceParams):
+      number {
+    return traceParameters.numberOfAnnontationEventsPerSpan >
+            DEFAULT_SPAN_MAX_NUM_ANNOTATIONS ?
+        DEFAULT_SPAN_MAX_NUM_ANNOTATIONS :
+        traceParameters.numberOfAnnontationEventsPerSpan;
+  }
+
+  static getNumberOfAttributesPerSpan(traceParameters: TraceParams): number {
+    return traceParameters.numberOfAttributesPerSpan >
+            DEFAULT_SPAN_MAX_NUM_ATTRIBUTES ?
+        DEFAULT_SPAN_MAX_NUM_ATTRIBUTES :
+        traceParameters.numberOfAttributesPerSpan;
+  }
+
+  static getNumberOfMessageEventsPerSpan(traceParameters: TraceParams): number {
+    return traceParameters.numberOfMessageEventsPerSpan >
+            DEFAULT_SPAN_MAX_NUM_MESSAGE_EVENTS ?
+        DEFAULT_SPAN_MAX_NUM_MESSAGE_EVENTS :
+        traceParameters.numberOfMessageEventsPerSpan;
+  }
+
+  static getNumberOfLinksPerSpan(traceParameters: TraceParams): number {
+    return traceParameters.numberOfLinksPerSpan > DEFAULT_SPAN_MAX_NUM_LINKS ?
+        DEFAULT_SPAN_MAX_NUM_LINKS :
+        traceParameters.numberOfLinksPerSpan;
+  }
+}
diff --git a/packages/opencensus-core/test/test-sampler.ts b/packages/opencensus-core/test/test-sampler.ts
@@ -15,12 +15,21 @@
  */
 
 import * as assert from 'assert';
+
+import {TraceParams} from '../src/trace/config/types';
 import {RootSpan} from '../src/trace/model/root-span';
 import {CoreTracer} from '../src/trace/model/tracer';
-import {SamplerBuilder} from '../src/trace/sampler/sampler';
+import {SamplerBuilder, TraceParamsBuilder} from '../src/trace/sampler/sampler';
 
 const tracer = new CoreTracer();
 
+const traceParameters: TraceParams = {
+  numberOfAnnontationEventsPerSpan: 12,
+  numberOfAttributesPerSpan: 10,
+  numberOfLinksPerSpan: 7,
+  numberOfMessageEventsPerSpan: 5
+};
+
 describe('Sampler', () => {
   /**
    * Should return true
@@ -100,4 +109,31 @@ describe('Sampler', () => {
          });
        });
   });
-});
+  describe('getNumberOfAnnotationEventsPerSpan', () => {
+    it('should return  12', () => {
+      assert.equal(
+          TraceParamsBuilder.getNumberOfAnnotationEventsPerSpan(
+              traceParameters),
+          12);
+    });
+  });
+  describe('getNumberOfMessageEventsPerSpan', () => {
+    it('should return 5', () => {
+      assert.equal(
+          TraceParamsBuilder.getNumberOfMessageEventsPerSpan(traceParameters),
+          5);
+    });
+  });
+  describe('getNumberOfAttributesPerSpan', () => {
+    it('should return 10', () => {
+      assert.equal(
+          TraceParamsBuilder.getNumberOfAttributesPerSpan(traceParameters), 10);
+    });
+  });
+  describe('getNumberOfLinksPerSpan', () => {
+    it('should return 7', () => {
+      assert.equal(
+          TraceParamsBuilder.getNumberOfLinksPerSpan(traceParameters), 7);
+    });
+  });
+});
diff --git a/packages/opencensus-core/test/test-tracer.ts b/packages/opencensus-core/test/test-tracer.ts
@@ -16,8 +16,10 @@
 
 import * as assert from 'assert';
 import * as uuid from 'uuid';
+
 import {randomSpanId} from '../src/internal/util';
 import {TracerConfig} from '../src/trace/config/types';
+import {TraceParams} from '../src/trace/config/types';
 import {RootSpan} from '../src/trace/model/root-span';
 import {Span} from '../src/trace/model/span';
 import {CoreTracer} from '../src/trace/model/tracer';
@@ -237,6 +239,37 @@ describe('Tracer', () => {
         assert.notEqual(rootSpan.parentSpanId, spanContextPropagated.spanId);
       });
     });
+
+    it('should create a tracer with default TraceParams when no parameters are specified upon initialisation',
+       () => {
+         const tracer = new CoreTracer();
+         tracer.start(defaultConfig);
+         assert.equal(
+             tracer.activeTraceParams.numberOfAnnontationEventsPerSpan, 32);
+         assert.equal(tracer.activeTraceParams.numberOfAttributesPerSpan, 32);
+         assert.equal(tracer.activeTraceParams.numberOfLinksPerSpan, 32);
+         assert.equal(
+             tracer.activeTraceParams.numberOfMessageEventsPerSpan, 128);
+       });
+
+    it('should create a tracer with default TraceParams when parameters with values higher than maximum limit are specified upon initialisation',
+       () => {
+         const traceParametersWithHigherThanMaximumValues: TraceParams = {
+           numberOfAnnontationEventsPerSpan: 50,
+           numberOfMessageEventsPerSpan: 200,
+           numberOfAttributesPerSpan: 37,
+           numberOfLinksPerSpan: 45
+         };
+         defaultConfig.traceParams = traceParametersWithHigherThanMaximumValues;
+         const tracer = new CoreTracer();
+         tracer.start(defaultConfig);
+         assert.equal(
+             tracer.activeTraceParams.numberOfAnnontationEventsPerSpan, 32);
+         assert.equal(tracer.activeTraceParams.numberOfAttributesPerSpan, 32);
+         assert.equal(tracer.activeTraceParams.numberOfLinksPerSpan, 32);
+         assert.equal(
+             tracer.activeTraceParams.numberOfMessageEventsPerSpan, 128);
+       });
   });