From f98ec08248d7e962738278473d762ab449eabe49 Mon Sep 17 00:00:00 2001 From: Vignesh Date: Thu, 31 Jan 2019 23:42:41 +0530 Subject: [PATCH] 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 --- .../opencensus-core/src/trace/config/types.ts | 17 ++++++++ .../opencensus-core/src/trace/model/tracer.ts | 28 +++++++++++- .../src/trace/sampler/sampler.ts | 43 +++++++++++++++++++ packages/opencensus-core/test/test-sampler.ts | 40 ++++++++++++++++- packages/opencensus-core/test/test-tracer.ts | 33 ++++++++++++++ 5 files changed, 157 insertions(+), 4 deletions(-) diff --git a/packages/opencensus-core/src/trace/config/types.ts b/packages/opencensus-core/src/trace/config/types.ts index 0b565f58b..a02c5dc25 100644 --- 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 index 3e28da131..53c5e1e25 100644 --- 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 index 699b40dc3..b4b3b6f1e 100644 --- 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 index 0c1e02753..929402735 100644 --- 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', () => { }); }); }); -}); \ No newline at end of file + 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 index 63acfecdd..a77e6f445 100644 --- 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); + }); });