diff --git a/CHANGELOG.md b/CHANGELOG.md index dc51015ffe0..0f0eef78c6f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -27,6 +27,7 @@ For notes on migrating to 2.x / 0.200.x see [the upgrade guide](doc/upgrade-to-2 * refactor(sdk-metrics): remove isNotNullish() utility function [#6151](https://github.com/open-telemetry/opentelemetry-js/pull/6151) @cjihrig * refactor(sdk-metrics): remove FlatMap() utility function [#6154](https://github.com/open-telemetry/opentelemetry-js/pull/6154) @cjihrig * refactor(sdk-metrics): simplify AllowList and DenyList processors [#6159](https://github.com/open-telemetry/opentelemetry-js/pull/6159) @cjihrig +* chore: disallow constructor parameter property syntax [#6187](https://github.com/open-telemetry/opentelemetry-js/pull/6187) @legendecas ## 2.2.0 diff --git a/api/CHANGELOG.md b/api/CHANGELOG.md index 7f01f8dc211..b9c38e2293d 100644 --- a/api/CHANGELOG.md +++ b/api/CHANGELOG.md @@ -22,6 +22,7 @@ fix(api): prioritize `esnext` export condition as it is more specific [#5458](ht * refactor(api): remove "export *" in favor of explicit named exports [#4880](https://github.com/open-telemetry/opentelemetry-js/pull/4880) @robbkidd * chore: enable tsconfig isolatedModules [#5697](https://github.com/open-telemetry/opentelemetry-js/pull/5697) @legendecas +* chore: disallow constructor parameter property syntax [#6187](https://github.com/open-telemetry/opentelemetry-js/pull/6187) @legendecas ## 1.9.0 diff --git a/api/src/trace/NonRecordingSpan.ts b/api/src/trace/NonRecordingSpan.ts index 9ee3d28837a..4386be10b48 100644 --- a/api/src/trace/NonRecordingSpan.ts +++ b/api/src/trace/NonRecordingSpan.ts @@ -29,9 +29,11 @@ import { Link } from './link'; * propagation. */ export class NonRecordingSpan implements Span { - constructor( - private readonly _spanContext: SpanContext = INVALID_SPAN_CONTEXT - ) {} + private readonly _spanContext: SpanContext; + + constructor(spanContext: SpanContext = INVALID_SPAN_CONTEXT) { + this._spanContext = spanContext; + } // Returns a SpanContext. spanContext(): SpanContext { diff --git a/api/src/trace/ProxyTracer.ts b/api/src/trace/ProxyTracer.ts index 6e19d6c493f..a378c58ad72 100644 --- a/api/src/trace/ProxyTracer.ts +++ b/api/src/trace/ProxyTracer.ts @@ -31,13 +31,22 @@ const NOOP_TRACER = new NoopTracer(); export class ProxyTracer implements Tracer { // When a real implementation is provided, this will be it private _delegate?: Tracer; + private _provider: TracerDelegator; + public readonly name: string; + public readonly version?: string; + public readonly options?: TracerOptions; constructor( - private _provider: TracerDelegator, - public readonly name: string, - public readonly version?: string, - public readonly options?: TracerOptions - ) {} + provider: TracerDelegator, + name: string, + version?: string, + options?: TracerOptions + ) { + this._provider = provider; + this.name = name; + this.version = version; + this.options = options; + } startSpan(name: string, options?: SpanOptions, context?: Context): Span { return this._getTracer().startSpan(name, options, context); diff --git a/eslint.base.js b/eslint.base.js index 255c6d748f5..efc8f1e89f7 100644 --- a/eslint.base.js +++ b/eslint.base.js @@ -51,6 +51,7 @@ module.exports = { "@typescript-eslint/no-empty-function": ["off"], "@typescript-eslint/no-unsafe-function-type": ["warn"], "@typescript-eslint/no-shadow": ["warn"], + "@typescript-eslint/parameter-properties": "error", "no-restricted-syntax": ["error", "ExportAllDeclaration"], "prefer-rest-params": "off", } diff --git a/experimental/CHANGELOG.md b/experimental/CHANGELOG.md index 87a96e61e39..688faf47435 100644 --- a/experimental/CHANGELOG.md +++ b/experimental/CHANGELOG.md @@ -40,6 +40,7 @@ For notes on migrating to 2.x / 0.200.x see [the upgrade guide](doc/upgrade-to-2 * refactor(opentelemetry-sdk-node): simplify calculation of validPropagators [#6143](https://github.com/open-telemetry/opentelemetry-js/pull/6143) @cjihrig * test(instrumentation-http): replace uses of deprecated abort() [#6149](https://github.com/open-telemetry/opentelemetry-js/pull/6149) @cjihrig * refactor(configuration): simplify boolean check [#6158](https://github.com/open-telemetry/opentelemetry-js/pull/6158) @cjihrig +* chore: disallow constructor parameter property syntax [#6187](https://github.com/open-telemetry/opentelemetry-js/pull/6187) @legendecas * refactor(otlp-transformer): migrate from protobufjs to protobuf-es [#6179](https://github.com/open-telemetry/opentelemetry-js/pull/6179) @overbalance * chore(otlp-transformer, sampler-composite): clean up tsconfig after protobuf-es migration [#6192](https://github.com/open-telemetry/opentelemetry-js/pull/6192) @overbalance diff --git a/experimental/packages/api-logs/src/ProxyLogger.ts b/experimental/packages/api-logs/src/ProxyLogger.ts index c6ce61c6f82..6cd4411890f 100644 --- a/experimental/packages/api-logs/src/ProxyLogger.ts +++ b/experimental/packages/api-logs/src/ProxyLogger.ts @@ -22,13 +22,22 @@ import { LogRecord } from './types/LogRecord'; export class ProxyLogger implements Logger { // When a real implementation is provided, this will be it private _delegate?: Logger; + private _provider: LoggerDelegator; + public readonly name: string; + public readonly version?: string | undefined; + public readonly options?: LoggerOptions | undefined; constructor( - private _provider: LoggerDelegator, - public readonly name: string, - public readonly version?: string | undefined, - public readonly options?: LoggerOptions | undefined - ) {} + provider: LoggerDelegator, + name: string, + version?: string | undefined, + options?: LoggerOptions | undefined + ) { + this._provider = provider; + this.name = name; + this.version = version; + this.options = options; + } /** * Emit a log record. This method should only be used by log appenders. diff --git a/experimental/packages/opentelemetry-exporter-prometheus/test/PrometheusExporter.test.ts b/experimental/packages/opentelemetry-exporter-prometheus/test/PrometheusExporter.test.ts index 651021cb5de..a7799f30134 100644 --- a/experimental/packages/opentelemetry-exporter-prometheus/test/PrometheusExporter.test.ts +++ b/experimental/packages/opentelemetry-exporter-prometheus/test/PrometheusExporter.test.ts @@ -614,8 +614,10 @@ describe('PrometheusExporter', () => { }); class RequestStatusError extends Error { - constructor(public statusCode: number | undefined) { + public statusCode: number | undefined; + constructor(statusCode: number | undefined) { super('request failed with non-200 code'); + this.statusCode = statusCode; } } diff --git a/experimental/packages/opentelemetry-instrumentation-http/test/utils/TestMetricReader.ts b/experimental/packages/opentelemetry-instrumentation-http/test/utils/TestMetricReader.ts index 12a59b11753..de7154fb931 100644 --- a/experimental/packages/opentelemetry-instrumentation-http/test/utils/TestMetricReader.ts +++ b/experimental/packages/opentelemetry-instrumentation-http/test/utils/TestMetricReader.ts @@ -17,11 +17,13 @@ import { MetricReader, PushMetricExporter } from '@opentelemetry/sdk-metrics'; export class TestMetricReader extends MetricReader { - constructor(private _exporter: PushMetricExporter) { + private _exporter: PushMetricExporter; + constructor(exporter: PushMetricExporter) { super({ aggregationTemporalitySelector: - _exporter.selectAggregationTemporality?.bind(_exporter), + exporter.selectAggregationTemporality?.bind(exporter), }); + this._exporter = exporter; } protected onForceFlush(): Promise { diff --git a/experimental/packages/opentelemetry-instrumentation-xml-http-request/test/xhr.test.ts b/experimental/packages/opentelemetry-instrumentation-xml-http-request/test/xhr.test.ts index 180036d2d84..87c6f0f17bf 100644 --- a/experimental/packages/opentelemetry-instrumentation-xml-http-request/test/xhr.test.ts +++ b/experimental/packages/opentelemetry-instrumentation-xml-http-request/test/xhr.test.ts @@ -198,7 +198,10 @@ function createMainResource(resource = {}): PerformanceResourceTiming { function createFakePerformanceObs(url: string) { class FakePerfObs implements PerformanceObserver { - constructor(private readonly cb: PerformanceObserverCallback) {} + private readonly cb: PerformanceObserverCallback; + constructor(cb: PerformanceObserverCallback) { + this.cb = cb; + } observe() { const absoluteUrl = url.startsWith('http') ? url : location.origin + url; diff --git a/experimental/packages/opentelemetry-instrumentation/src/instrumentation.ts b/experimental/packages/opentelemetry-instrumentation/src/instrumentation.ts index 572de28e18b..e5454eb604c 100644 --- a/experimental/packages/opentelemetry-instrumentation/src/instrumentation.ts +++ b/experimental/packages/opentelemetry-instrumentation/src/instrumentation.ts @@ -47,12 +47,17 @@ export abstract class InstrumentationAbstract< private _meter: Meter; private _logger: Logger; protected _diag: DiagLogger; + public readonly instrumentationName: string; + public readonly instrumentationVersion: string; constructor( - public readonly instrumentationName: string, - public readonly instrumentationVersion: string, + instrumentationName: string, + instrumentationVersion: string, config: ConfigType ) { + this.instrumentationName = instrumentationName; + this.instrumentationVersion = instrumentationVersion; + this.setConfig(config); this._diag = diag.createComponentLogger({ diff --git a/experimental/packages/opentelemetry-instrumentation/src/instrumentationNodeModuleDefinition.ts b/experimental/packages/opentelemetry-instrumentation/src/instrumentationNodeModuleDefinition.ts index 2d17ce3cf3d..7912ec6e247 100644 --- a/experimental/packages/opentelemetry-instrumentation/src/instrumentationNodeModuleDefinition.ts +++ b/experimental/packages/opentelemetry-instrumentation/src/instrumentationNodeModuleDefinition.ts @@ -23,15 +23,23 @@ export class InstrumentationNodeModuleDefinition implements InstrumentationModuleDefinition { files: InstrumentationModuleFile[]; + public name: string; + public supportedVersions: string[]; + public patch; + public unpatch; constructor( - public name: string, - public supportedVersions: string[], + name: string, + supportedVersions: string[], // eslint-disable-next-line @typescript-eslint/no-explicit-any - public patch?: (exports: any, moduleVersion?: string) => any, + patch?: (exports: any, moduleVersion?: string) => any, // eslint-disable-next-line @typescript-eslint/no-explicit-any - public unpatch?: (exports: any, moduleVersion?: string) => void, + unpatch?: (exports: any, moduleVersion?: string) => void, files?: InstrumentationModuleFile[] ) { this.files = files || []; + this.name = name; + this.supportedVersions = supportedVersions; + this.patch = patch; + this.unpatch = unpatch; } } diff --git a/experimental/packages/opentelemetry-instrumentation/src/instrumentationNodeModuleFile.ts b/experimental/packages/opentelemetry-instrumentation/src/instrumentationNodeModuleFile.ts index b821552b9f5..b1d0090946b 100644 --- a/experimental/packages/opentelemetry-instrumentation/src/instrumentationNodeModuleFile.ts +++ b/experimental/packages/opentelemetry-instrumentation/src/instrumentationNodeModuleFile.ts @@ -21,14 +21,21 @@ export class InstrumentationNodeModuleFile implements InstrumentationModuleFile { public name: string; + public supportedVersions: string[]; + public patch; + public unpatch; + constructor( name: string, - public supportedVersions: string[], + supportedVersions: string[], // eslint-disable-next-line @typescript-eslint/no-explicit-any - public patch: (moduleExports: any, moduleVersion?: string) => any, + patch: (moduleExports: any, moduleVersion?: string) => any, // eslint-disable-next-line @typescript-eslint/no-explicit-any - public unpatch: (moduleExports?: any, moduleVersion?: string) => void + unpatch: (moduleExports?: any, moduleVersion?: string) => void ) { this.name = normalize(name); + this.supportedVersions = supportedVersions; + this.patch = patch; + this.unpatch = unpatch; } } diff --git a/experimental/packages/otlp-exporter-base/src/OTLPExporterBase.ts b/experimental/packages/otlp-exporter-base/src/OTLPExporterBase.ts index 1459cdaba83..c2bc0a5ae3b 100644 --- a/experimental/packages/otlp-exporter-base/src/OTLPExporterBase.ts +++ b/experimental/packages/otlp-exporter-base/src/OTLPExporterBase.ts @@ -18,7 +18,10 @@ import { ExportResult } from '@opentelemetry/core'; import { IOtlpExportDelegate } from './otlp-export-delegate'; export class OTLPExporterBase { - constructor(private _delegate: IOtlpExportDelegate) {} + private _delegate: IOtlpExportDelegate; + constructor(delegate: IOtlpExportDelegate) { + this._delegate = delegate; + } /** * Export items. diff --git a/experimental/packages/otlp-exporter-base/src/otlp-export-delegate.ts b/experimental/packages/otlp-exporter-base/src/otlp-export-delegate.ts index 00d8113a799..6feabd3c2a5 100644 --- a/experimental/packages/otlp-exporter-base/src/otlp-export-delegate.ts +++ b/experimental/packages/otlp-exporter-base/src/otlp-export-delegate.ts @@ -39,13 +39,24 @@ class OTLPExportDelegate implements IOtlpExportDelegate { private _diagLogger: DiagLogger; + private _transport: IExporterTransport; + private _serializer: ISerializer; + private _responseHandler: IOtlpResponseHandler; + private _promiseQueue: IExportPromiseHandler; + private _timeout: number; + constructor( - private _transport: IExporterTransport, - private _serializer: ISerializer, - private _responseHandler: IOtlpResponseHandler, - private _promiseQueue: IExportPromiseHandler, - private _timeout: number + transport: IExporterTransport, + serializer: ISerializer, + responseHandler: IOtlpResponseHandler, + promiseQueue: IExportPromiseHandler, + timeout: number ) { + this._transport = transport; + this._serializer = serializer; + this._responseHandler = responseHandler; + this._promiseQueue = promiseQueue; + this._timeout = timeout; this._diagLogger = diag.createComponentLogger({ namespace: 'OTLPExportDelegate', }); diff --git a/experimental/packages/otlp-exporter-base/src/retrying-transport.ts b/experimental/packages/otlp-exporter-base/src/retrying-transport.ts index c85ae8e07e9..4e1cda3164b 100644 --- a/experimental/packages/otlp-exporter-base/src/retrying-transport.ts +++ b/experimental/packages/otlp-exporter-base/src/retrying-transport.ts @@ -31,7 +31,11 @@ function getJitter() { } class RetryingTransport implements IExporterTransport { - constructor(private _transport: IExporterTransport) {} + private _transport: IExporterTransport; + + constructor(transport: IExporterTransport) { + this._transport = transport; + } private retry( data: Uint8Array, diff --git a/experimental/packages/otlp-exporter-base/src/transport/fetch-transport.ts b/experimental/packages/otlp-exporter-base/src/transport/fetch-transport.ts index 03cf7425ec2..66a7e3eaa0a 100644 --- a/experimental/packages/otlp-exporter-base/src/transport/fetch-transport.ts +++ b/experimental/packages/otlp-exporter-base/src/transport/fetch-transport.ts @@ -29,7 +29,11 @@ export interface FetchTransportParameters { } class FetchTransport implements IExporterTransport { - constructor(private _parameters: FetchTransportParameters) {} + private _parameters: FetchTransportParameters; + + constructor(parameters: FetchTransportParameters) { + this._parameters = parameters; + } async send(data: Uint8Array, timeoutMillis: number): Promise { const abortController = new AbortController(); diff --git a/experimental/packages/otlp-exporter-base/src/transport/http-exporter-transport.ts b/experimental/packages/otlp-exporter-base/src/transport/http-exporter-transport.ts index 9bef885476b..48e6f9f1c1c 100644 --- a/experimental/packages/otlp-exporter-base/src/transport/http-exporter-transport.ts +++ b/experimental/packages/otlp-exporter-base/src/transport/http-exporter-transport.ts @@ -30,8 +30,11 @@ interface Utils { class HttpExporterTransport implements IExporterTransport { private _utils: Utils | null = null; + private _parameters: NodeHttpRequestParameters; - constructor(private _parameters: NodeHttpRequestParameters) {} + constructor(parameters: NodeHttpRequestParameters) { + this._parameters = parameters; + } async send(data: Uint8Array, timeoutMillis: number): Promise { const { agent, request } = await this._loadUtils(); diff --git a/experimental/packages/otlp-exporter-base/src/transport/send-beacon-transport.ts b/experimental/packages/otlp-exporter-base/src/transport/send-beacon-transport.ts index 36a50a1f1a6..a14b29d0cc0 100644 --- a/experimental/packages/otlp-exporter-base/src/transport/send-beacon-transport.ts +++ b/experimental/packages/otlp-exporter-base/src/transport/send-beacon-transport.ts @@ -29,7 +29,11 @@ export interface SendBeaconParameters { } class SendBeaconTransport implements IExporterTransport { - constructor(private _params: SendBeaconParameters) {} + private _params: SendBeaconParameters; + constructor(params: SendBeaconParameters) { + this._params = params; + } + async send(data: Uint8Array): Promise { const blobType = (await this._params.headers())['Content-Type']; return new Promise(resolve => { diff --git a/experimental/packages/otlp-exporter-base/src/transport/xhr-transport.ts b/experimental/packages/otlp-exporter-base/src/transport/xhr-transport.ts index cf16c6bff64..5a0275dd462 100644 --- a/experimental/packages/otlp-exporter-base/src/transport/xhr-transport.ts +++ b/experimental/packages/otlp-exporter-base/src/transport/xhr-transport.ts @@ -35,7 +35,11 @@ export interface XhrRequestParameters { } class XhrTransport implements IExporterTransport { - constructor(private _parameters: XhrRequestParameters) {} + private _parameters: XhrRequestParameters; + + constructor(parameters: XhrRequestParameters) { + this._parameters = parameters; + } async send(data: Uint8Array, timeoutMillis: number): Promise { const headers = await this._parameters.headers(); diff --git a/experimental/packages/otlp-grpc-exporter-base/src/grpc-exporter-transport.ts b/experimental/packages/otlp-grpc-exporter-base/src/grpc-exporter-transport.ts index 1adb3a0b9da..01103ca777a 100644 --- a/experimental/packages/otlp-grpc-exporter-base/src/grpc-exporter-transport.ts +++ b/experimental/packages/otlp-grpc-exporter-base/src/grpc-exporter-transport.ts @@ -105,8 +105,11 @@ export interface GrpcExporterTransportParameters { export class GrpcExporterTransport implements IExporterTransport { private _client?: Client; private _metadata?: Metadata; + private _parameters: GrpcExporterTransportParameters; - constructor(private _parameters: GrpcExporterTransportParameters) {} + constructor(parameters: GrpcExporterTransportParameters) { + this._parameters = parameters; + } shutdown() { this._client?.close(); diff --git a/experimental/packages/sampler-composite/src/composite.ts b/experimental/packages/sampler-composite/src/composite.ts index 0a8a90e0620..428e6198869 100644 --- a/experimental/packages/sampler-composite/src/composite.ts +++ b/experimental/packages/sampler-composite/src/composite.ts @@ -36,7 +36,11 @@ import { } from './util'; class CompositeSampler implements Sampler { - constructor(private readonly delegate: ComposableSampler) {} + private readonly delegate: ComposableSampler; + + constructor(delegate: ComposableSampler) { + this.delegate = delegate; + } shouldSample( context: Context, diff --git a/experimental/packages/sampler-composite/src/parentthreshold.ts b/experimental/packages/sampler-composite/src/parentthreshold.ts index a01a8d4eda1..9eef4f421ec 100644 --- a/experimental/packages/sampler-composite/src/parentthreshold.ts +++ b/experimental/packages/sampler-composite/src/parentthreshold.ts @@ -29,8 +29,10 @@ import { INVALID_THRESHOLD, isValidThreshold, MIN_THRESHOLD } from './util'; class ComposableParentThresholdSampler implements ComposableSampler { private readonly description: string; + private readonly rootSampler: ComposableSampler; - constructor(private readonly rootSampler: ComposableSampler) { + constructor(rootSampler: ComposableSampler) { + this.rootSampler = rootSampler; this.description = `ComposableParentThresholdSampler(rootSampler=${rootSampler})`; } diff --git a/experimental/packages/sdk-logs/src/Logger.ts b/experimental/packages/sdk-logs/src/Logger.ts index e7d42dbf733..7cf46546979 100644 --- a/experimental/packages/sdk-logs/src/Logger.ts +++ b/experimental/packages/sdk-logs/src/Logger.ts @@ -22,10 +22,16 @@ import { LogRecordImpl } from './LogRecordImpl'; import { LoggerProviderSharedState } from './internal/LoggerProviderSharedState'; export class Logger implements logsAPI.Logger { + public readonly instrumentationScope: InstrumentationScope; + private _sharedState: LoggerProviderSharedState; + constructor( - public readonly instrumentationScope: InstrumentationScope, - private _sharedState: LoggerProviderSharedState - ) {} + instrumentationScope: InstrumentationScope, + sharedState: LoggerProviderSharedState + ) { + this.instrumentationScope = instrumentationScope; + this._sharedState = sharedState; + } public emit(logRecord: logsAPI.LogRecord): void { const currentContext = logRecord.context || context.active(); diff --git a/experimental/packages/sdk-logs/src/MultiLogRecordProcessor.ts b/experimental/packages/sdk-logs/src/MultiLogRecordProcessor.ts index 9913af18d63..b706cca9135 100644 --- a/experimental/packages/sdk-logs/src/MultiLogRecordProcessor.ts +++ b/experimental/packages/sdk-logs/src/MultiLogRecordProcessor.ts @@ -24,10 +24,15 @@ import type { SdkLogRecord } from './export/SdkLogRecord'; * received events to a list of {@link LogRecordProcessor}s. */ export class MultiLogRecordProcessor implements LogRecordProcessor { + public readonly processors: LogRecordProcessor[]; + public readonly forceFlushTimeoutMillis: number; constructor( - public readonly processors: LogRecordProcessor[], - public readonly forceFlushTimeoutMillis: number - ) {} + processors: LogRecordProcessor[], + forceFlushTimeoutMillis: number + ) { + this.processors = processors; + this.forceFlushTimeoutMillis = forceFlushTimeoutMillis; + } public async forceFlush(): Promise { const timeout = this.forceFlushTimeoutMillis; diff --git a/experimental/packages/sdk-logs/src/export/BatchLogRecordProcessorBase.ts b/experimental/packages/sdk-logs/src/export/BatchLogRecordProcessorBase.ts index 001ec7b8119..6f67915514f 100644 --- a/experimental/packages/sdk-logs/src/export/BatchLogRecordProcessorBase.ts +++ b/experimental/packages/sdk-logs/src/export/BatchLogRecordProcessorBase.ts @@ -37,16 +37,15 @@ export abstract class BatchLogRecordProcessorBase private readonly _maxQueueSize: number; private readonly _scheduledDelayMillis: number; private readonly _exportTimeoutMillis: number; + private readonly _exporter: LogRecordExporter; private _isExporting = false; private _finishedLogRecords: SdkLogRecord[] = []; private _timer: NodeJS.Timeout | number | undefined; private _shutdownOnce: BindOnceFuture; - constructor( - private readonly _exporter: LogRecordExporter, - config?: T - ) { + constructor(exporter: LogRecordExporter, config?: T) { + this._exporter = exporter; this._maxExportBatchSize = config?.maxExportBatchSize ?? getNumberFromEnv('OTEL_BLRP_MAX_EXPORT_BATCH_SIZE') ?? diff --git a/experimental/packages/sdk-logs/src/export/SimpleLogRecordProcessor.ts b/experimental/packages/sdk-logs/src/export/SimpleLogRecordProcessor.ts index f42c3094bd8..fd3aa2755f6 100644 --- a/experimental/packages/sdk-logs/src/export/SimpleLogRecordProcessor.ts +++ b/experimental/packages/sdk-logs/src/export/SimpleLogRecordProcessor.ts @@ -35,10 +35,12 @@ import type { SdkLogRecord } from './SdkLogRecord'; * using the {@link BatchLogRecordProcessor} instead. */ export class SimpleLogRecordProcessor implements LogRecordProcessor { + private readonly _exporter: LogRecordExporter; private _shutdownOnce: BindOnceFuture; private _unresolvedExports: Set>; - constructor(private readonly _exporter: LogRecordExporter) { + constructor(exporter: LogRecordExporter) { + this._exporter = exporter; this._shutdownOnce = new BindOnceFuture(this._shutdown, this); this._unresolvedExports = new Set>(); } diff --git a/experimental/packages/sdk-logs/src/internal/LoggerProviderSharedState.ts b/experimental/packages/sdk-logs/src/internal/LoggerProviderSharedState.ts index 7580e300827..4450237689e 100644 --- a/experimental/packages/sdk-logs/src/internal/LoggerProviderSharedState.ts +++ b/experimental/packages/sdk-logs/src/internal/LoggerProviderSharedState.ts @@ -25,13 +25,21 @@ export class LoggerProviderSharedState { readonly loggers: Map = new Map(); activeProcessor: LogRecordProcessor; readonly registeredLogRecordProcessors: LogRecordProcessor[] = []; + readonly resource: Resource; + readonly forceFlushTimeoutMillis: number; + readonly logRecordLimits: Required; + readonly processors: LogRecordProcessor[]; constructor( - readonly resource: Resource, - readonly forceFlushTimeoutMillis: number, - readonly logRecordLimits: Required, - readonly processors: LogRecordProcessor[] + resource: Resource, + forceFlushTimeoutMillis: number, + logRecordLimits: Required, + processors: LogRecordProcessor[] ) { + this.resource = resource; + this.forceFlushTimeoutMillis = forceFlushTimeoutMillis; + this.logRecordLimits = logRecordLimits; + this.processors = processors; if (processors.length > 0) { this.registeredLogRecordProcessors = processors; this.activeProcessor = new MultiLogRecordProcessor( diff --git a/experimental/packages/shim-opencensus/src/ShimTracer.ts b/experimental/packages/shim-opencensus/src/ShimTracer.ts index 0f479e93d12..664313e6081 100644 --- a/experimental/packages/shim-opencensus/src/ShimTracer.ts +++ b/experimental/packages/shim-opencensus/src/ShimTracer.ts @@ -53,8 +53,11 @@ export class ShimTracer implements oc.Tracer { eventListeners: oc.SpanEventListener[] = []; // Uses the global OpenTelemetry propagator by default propagation: oc.Propagation = shimPropagation; + private otelTracer: Tracer; - constructor(private otelTracer: Tracer) {} + constructor(otelTracer: Tracer) { + this.otelTracer = otelTracer; + } start({ propagation }: oc.TracerConfig): this { this.active = true; diff --git a/experimental/packages/shim-opencensus/src/propagation.ts b/experimental/packages/shim-opencensus/src/propagation.ts index e0045fe7d95..a58a9580d37 100644 --- a/experimental/packages/shim-opencensus/src/propagation.ts +++ b/experimental/packages/shim-opencensus/src/propagation.ts @@ -26,7 +26,11 @@ import { import { mapSpanContext, reverseMapSpanContext } from './trace-transform'; class Getter implements TextMapGetter { - constructor(private ocGetter: oc.HeaderGetter) {} + private ocGetter: oc.HeaderGetter; + + constructor(ocGetter: oc.HeaderGetter) { + this.ocGetter = ocGetter; + } keys(): string[] { return []; } @@ -36,7 +40,12 @@ class Getter implements TextMapGetter { } class Setter implements TextMapSetter { - constructor(private ocSetter: oc.HeaderSetter) {} + private ocSetter: oc.HeaderSetter; + + constructor(ocSetter: oc.HeaderSetter) { + this.ocSetter = ocSetter; + } + set(carrier: void, key: string, value: string): void { this.ocSetter.setHeader(key, value); } diff --git a/packages/opentelemetry-core/src/utils/callback.ts b/packages/opentelemetry-core/src/utils/callback.ts index 56c900c2abc..a14d7e806a6 100644 --- a/packages/opentelemetry-core/src/utils/callback.ts +++ b/packages/opentelemetry-core/src/utils/callback.ts @@ -26,10 +26,13 @@ export class BindOnceFuture< > { private _isCalled = false; private _deferred = new Deferred(); - constructor( - private _callback: T, - private _that: This - ) {} + private _callback: T; + private _that: This; + + constructor(callback: T, that: This) { + this._callback = callback; + this._that = that; + } get isCalled() { return this._isCalled; diff --git a/packages/opentelemetry-core/test/common/utils/merge.test.ts b/packages/opentelemetry-core/test/common/utils/merge.test.ts index a3571366a29..2c2ba8989cd 100644 --- a/packages/opentelemetry-core/test/common/utils/merge.test.ts +++ b/packages/opentelemetry-core/test/common/utils/merge.test.ts @@ -264,7 +264,10 @@ tests.push({ }); class A { - constructor(private _name = 'foo') {} + private _name: string; + constructor(name = 'foo') { + this._name = name; + } getName() { return this._name; @@ -272,11 +275,10 @@ class A { } class B extends A { - constructor( - name = 'foo', - private _ver = 1 - ) { + private _ver: number; + constructor(name = 'foo', ver = 1) { super(name); + this._ver = ver; } getVer() { return this._ver; diff --git a/packages/opentelemetry-sdk-trace-base/src/MultiSpanProcessor.ts b/packages/opentelemetry-sdk-trace-base/src/MultiSpanProcessor.ts index 94ed7154cf3..222599eb45e 100644 --- a/packages/opentelemetry-sdk-trace-base/src/MultiSpanProcessor.ts +++ b/packages/opentelemetry-sdk-trace-base/src/MultiSpanProcessor.ts @@ -25,7 +25,10 @@ import { SpanProcessor } from './SpanProcessor'; * received events to a list of {@link SpanProcessor}s. */ export class MultiSpanProcessor implements SpanProcessor { - constructor(private readonly _spanProcessors: SpanProcessor[]) {} + private readonly _spanProcessors: SpanProcessor[]; + constructor(spanProcessors: SpanProcessor[]) { + this._spanProcessors = spanProcessors; + } forceFlush(): Promise { const promises: Promise[] = []; diff --git a/packages/opentelemetry-sdk-trace-base/src/export/BatchSpanProcessorBase.ts b/packages/opentelemetry-sdk-trace-base/src/export/BatchSpanProcessorBase.ts index b4cd0a51f9f..254cf126648 100644 --- a/packages/opentelemetry-sdk-trace-base/src/export/BatchSpanProcessorBase.ts +++ b/packages/opentelemetry-sdk-trace-base/src/export/BatchSpanProcessorBase.ts @@ -39,6 +39,7 @@ export abstract class BatchSpanProcessorBase private readonly _maxQueueSize: number; private readonly _scheduledDelayMillis: number; private readonly _exportTimeoutMillis: number; + private readonly _exporter: SpanExporter; private _isExporting = false; private _finishedSpans: ReadableSpan[] = []; @@ -46,10 +47,8 @@ export abstract class BatchSpanProcessorBase private _shutdownOnce: BindOnceFuture; private _droppedSpansCount: number = 0; - constructor( - private readonly _exporter: SpanExporter, - config?: T - ) { + constructor(exporter: SpanExporter, config?: T) { + this._exporter = exporter; this._maxExportBatchSize = typeof config?.maxExportBatchSize === 'number' ? config.maxExportBatchSize diff --git a/packages/opentelemetry-sdk-trace-base/src/export/SimpleSpanProcessor.ts b/packages/opentelemetry-sdk-trace-base/src/export/SimpleSpanProcessor.ts index 2dbdf19382e..a3f782410cf 100644 --- a/packages/opentelemetry-sdk-trace-base/src/export/SimpleSpanProcessor.ts +++ b/packages/opentelemetry-sdk-trace-base/src/export/SimpleSpanProcessor.ts @@ -35,10 +35,12 @@ import { SpanExporter } from './SpanExporter'; * NOTE: This {@link SpanProcessor} exports every ended span individually instead of batching spans together, which causes significant performance overhead with most exporters. For production use, please consider using the {@link BatchSpanProcessor} instead. */ export class SimpleSpanProcessor implements SpanProcessor { + private readonly _exporter: SpanExporter; private _shutdownOnce: BindOnceFuture; private _pendingExports: Set>; - constructor(private readonly _exporter: SpanExporter) { + constructor(exporter: SpanExporter) { + this._exporter = exporter; this._shutdownOnce = new BindOnceFuture(this._shutdown, this); this._pendingExports = new Set>(); } diff --git a/packages/opentelemetry-sdk-trace-base/src/sampler/TraceIdRatioBasedSampler.ts b/packages/opentelemetry-sdk-trace-base/src/sampler/TraceIdRatioBasedSampler.ts index eae29b29716..3a4255cf01b 100644 --- a/packages/opentelemetry-sdk-trace-base/src/sampler/TraceIdRatioBasedSampler.ts +++ b/packages/opentelemetry-sdk-trace-base/src/sampler/TraceIdRatioBasedSampler.ts @@ -19,10 +19,11 @@ import { Sampler, SamplingDecision, SamplingResult } from '../Sampler'; /** Sampler that samples a given fraction of traces based of trace id deterministically. */ export class TraceIdRatioBasedSampler implements Sampler { + private readonly _ratio; private _upperBound: number; - constructor(private readonly _ratio = 0) { - this._ratio = this._normalize(_ratio); + constructor(ratio = 0) { + this._ratio = this._normalize(ratio); this._upperBound = Math.floor(this._ratio * 0xffffffff); } diff --git a/packages/opentelemetry-sdk-trace-base/test/common/Tracer.test.ts b/packages/opentelemetry-sdk-trace-base/test/common/Tracer.test.ts index ba4ab00016c..e1c00d428d6 100644 --- a/packages/opentelemetry-sdk-trace-base/test/common/Tracer.test.ts +++ b/packages/opentelemetry-sdk-trace-base/test/common/Tracer.test.ts @@ -52,7 +52,11 @@ describe('Tracer', () => { const tracerProvider = new BasicTracerProvider(); class TestSampler implements Sampler { - constructor(private readonly traceState?: TraceState) {} + private readonly traceState?: TraceState; + + constructor(traceState?: TraceState) { + this.traceState = traceState; + } shouldSample( _context: Context, diff --git a/packages/sdk-metrics/src/Instruments.ts b/packages/sdk-metrics/src/Instruments.ts index 6d60792effe..d060ecbe8ff 100644 --- a/packages/sdk-metrics/src/Instruments.ts +++ b/packages/sdk-metrics/src/Instruments.ts @@ -39,10 +39,16 @@ import { } from './state/WritableMetricStorage'; export class SyncInstrument { + private _writableMetricStorage: WritableMetricStorage; + protected _descriptor: InstrumentDescriptor; + constructor( - private _writableMetricStorage: WritableMetricStorage, - protected _descriptor: InstrumentDescriptor - ) {} + writableMetricStorage: WritableMetricStorage, + descriptor: InstrumentDescriptor + ) { + this._writableMetricStorage = writableMetricStorage; + this._descriptor = descriptor; + } protected _record( value: number, @@ -146,14 +152,16 @@ export class ObservableInstrument implements Observable { _metricStorages: AsyncWritableMetricStorage[]; /** @internal */ _descriptor: InstrumentDescriptor; + private _observableRegistry: ObservableRegistry; constructor( descriptor: InstrumentDescriptor, metricStorages: AsyncWritableMetricStorage[], - private _observableRegistry: ObservableRegistry + observableRegistry: ObservableRegistry ) { this._descriptor = descriptor; this._metricStorages = metricStorages; + this._observableRegistry = observableRegistry; } /** diff --git a/packages/sdk-metrics/src/Meter.ts b/packages/sdk-metrics/src/Meter.ts index 1d6548427d4..b25adf68042 100644 --- a/packages/sdk-metrics/src/Meter.ts +++ b/packages/sdk-metrics/src/Meter.ts @@ -44,7 +44,10 @@ import { InstrumentType } from './export/MetricData'; * This class implements the {@link IMeter} interface. */ export class Meter implements IMeter { - constructor(private _meterSharedState: MeterSharedState) {} + private _meterSharedState: MeterSharedState; + constructor(meterSharedState: MeterSharedState) { + this._meterSharedState = meterSharedState; + } /** * Create a {@link Gauge} instrument. diff --git a/packages/sdk-metrics/src/ObservableResult.ts b/packages/sdk-metrics/src/ObservableResult.ts index 842a270e597..2d3cd963130 100644 --- a/packages/sdk-metrics/src/ObservableResult.ts +++ b/packages/sdk-metrics/src/ObservableResult.ts @@ -33,11 +33,13 @@ export class ObservableResultImpl implements ObservableResult { * @internal */ _buffer = new AttributeHashMap(); + private _instrumentName: string; + private _valueType: ValueType; - constructor( - private _instrumentName: string, - private _valueType: ValueType - ) {} + constructor(instrumentName: string, valueType: ValueType) { + this._instrumentName = instrumentName; + this._valueType = valueType; + } /** * Observe a measurement of the value associated with the given attributes. diff --git a/packages/sdk-metrics/src/aggregator/ExponentialHistogram.ts b/packages/sdk-metrics/src/aggregator/ExponentialHistogram.ts index c1675d34bdf..5fa1717f7f7 100644 --- a/packages/sdk-metrics/src/aggregator/ExponentialHistogram.ts +++ b/packages/sdk-metrics/src/aggregator/ExponentialHistogram.ts @@ -53,10 +53,13 @@ class HighLow { static combine(h1: HighLow, h2: HighLow): HighLow { return new HighLow(Math.min(h1.low, h2.low), Math.max(h1.high, h2.high)); } - constructor( - public low: number, - public high: number - ) {} + + public low: number; + public high: number; + constructor(low: number, high: number) { + this.low = low; + this.high = high; + } } const MAX_SCALE = 20; @@ -64,19 +67,43 @@ const DEFAULT_MAX_SIZE = 160; const MIN_MAX_SIZE = 2; export class ExponentialHistogramAccumulation implements Accumulation { + public startTime; + private _maxSize; + private _recordMinMax; + private _sum; + private _count; + private _zeroCount; + private _min; + private _max; + private _positive; + private _negative; + private _mapping; + constructor( - public startTime: HrTime, - private _maxSize = DEFAULT_MAX_SIZE, - private _recordMinMax = true, - private _sum = 0, - private _count = 0, - private _zeroCount = 0, - private _min = Number.POSITIVE_INFINITY, - private _max = Number.NEGATIVE_INFINITY, - private _positive = new Buckets(), - private _negative = new Buckets(), - private _mapping: Mapping = getMapping(MAX_SCALE) + startTime: HrTime, + maxSize = DEFAULT_MAX_SIZE, + recordMinMax = true, + sum = 0, + count = 0, + zeroCount = 0, + min = Number.POSITIVE_INFINITY, + max = Number.NEGATIVE_INFINITY, + positive = new Buckets(), + negative = new Buckets(), + mapping: Mapping = getMapping(MAX_SCALE) ) { + this.startTime = startTime; + this._maxSize = maxSize; + this._recordMinMax = recordMinMax; + this._sum = sum; + this._count = count; + this._zeroCount = zeroCount; + this._min = min; + this._max = max; + this._positive = positive; + this._negative = negative; + this._mapping = mapping; + if (this._maxSize < MIN_MAX_SIZE) { diag.warn(`Exponential Histogram Max Size set to ${this._maxSize}, \ changing to the minimum size of: ${MIN_MAX_SIZE}`); @@ -520,16 +547,18 @@ export class ExponentialHistogramAggregator public kind: AggregatorKind.EXPONENTIAL_HISTOGRAM = AggregatorKind.EXPONENTIAL_HISTOGRAM; + readonly _maxSize: number; + private readonly _recordMinMax: boolean; /** * @param _maxSize Maximum number of buckets for each of the positive * and negative ranges, exclusive of the zero-bucket. * @param _recordMinMax If set to true, min and max will be recorded. * Otherwise, min and max will not be recorded. */ - constructor( - readonly _maxSize: number, - private readonly _recordMinMax: boolean - ) {} + constructor(maxSize: number, recordMinMax: boolean) { + this._maxSize = maxSize; + this._recordMinMax = recordMinMax; + } createAccumulation(startTime: HrTime) { return new ExponentialHistogramAccumulation( diff --git a/packages/sdk-metrics/src/aggregator/Histogram.ts b/packages/sdk-metrics/src/aggregator/Histogram.ts index 09fae6c122b..65ae69cc5e4 100644 --- a/packages/sdk-metrics/src/aggregator/Histogram.ts +++ b/packages/sdk-metrics/src/aggregator/Histogram.ts @@ -64,12 +64,22 @@ function createNewEmptyCheckpoint(boundaries: number[]): InternalHistogram { } export class HistogramAccumulation implements Accumulation { + public startTime; + private readonly _boundaries; + private _recordMinMax; + private _current; + constructor( - public startTime: HrTime, - private readonly _boundaries: number[], - private _recordMinMax = true, - private _current: InternalHistogram = createNewEmptyCheckpoint(_boundaries) - ) {} + startTime: HrTime, + boundaries: number[], + recordMinMax = true, + current: InternalHistogram = createNewEmptyCheckpoint(boundaries) + ) { + this.startTime = startTime; + this._boundaries = boundaries; + this._recordMinMax = recordMinMax; + this._current = current; + } record(value: number): void { // NaN does not fall into any bucket, is not zero and should not be counted, @@ -106,15 +116,17 @@ export class HistogramAccumulation implements Accumulation { */ export class HistogramAggregator implements Aggregator { public kind: AggregatorKind.HISTOGRAM = AggregatorKind.HISTOGRAM; + private readonly _boundaries: number[]; + private readonly _recordMinMax: boolean; /** * @param _boundaries sorted upper bounds of recorded values. * @param _recordMinMax If set to true, min and max will be recorded. Otherwise, min and max will not be recorded. */ - constructor( - private readonly _boundaries: number[], - private readonly _recordMinMax: boolean - ) {} + constructor(boundaries: number[], recordMinMax: boolean) { + this._boundaries = boundaries; + this._recordMinMax = recordMinMax; + } createAccumulation(startTime: HrTime) { return new HistogramAccumulation( diff --git a/packages/sdk-metrics/src/aggregator/LastValue.ts b/packages/sdk-metrics/src/aggregator/LastValue.ts index 6afe09f82a4..ed1876a82be 100644 --- a/packages/sdk-metrics/src/aggregator/LastValue.ts +++ b/packages/sdk-metrics/src/aggregator/LastValue.ts @@ -29,11 +29,15 @@ import { AggregationTemporality } from '../export/AggregationTemporality'; import { InstrumentDescriptor } from '../InstrumentDescriptor'; export class LastValueAccumulation implements Accumulation { - constructor( - public startTime: HrTime, - private _current = 0, - public sampleTime: HrTime = [0, 0] - ) {} + public startTime; + private _current; + public sampleTime; + + constructor(startTime: HrTime, current = 0, sampleTime: HrTime = [0, 0]) { + this.startTime = startTime; + this._current = current; + this.sampleTime = sampleTime; + } record(value: number): void { this._current = value; diff --git a/packages/sdk-metrics/src/aggregator/Sum.ts b/packages/sdk-metrics/src/aggregator/Sum.ts index 2cf00cba4f3..e2cc3e0328c 100644 --- a/packages/sdk-metrics/src/aggregator/Sum.ts +++ b/packages/sdk-metrics/src/aggregator/Sum.ts @@ -28,12 +28,22 @@ import { AggregationTemporality } from '../export/AggregationTemporality'; import { InstrumentDescriptor } from '../InstrumentDescriptor'; export class SumAccumulation implements Accumulation { + public startTime; + public monotonic; + private _current; + public reset; + constructor( - public startTime: HrTime, - public monotonic: boolean, - private _current = 0, - public reset = false - ) {} + startTime: HrTime, + monotonic: boolean, + current = 0, + reset = false + ) { + this.startTime = startTime; + this.monotonic = monotonic; + this._current = current; + this.reset = reset; + } record(value: number): void { if (this.monotonic && value < 0) { @@ -54,8 +64,11 @@ export class SumAccumulation implements Accumulation { /** Basic aggregator which calculates a Sum from individual measurements. */ export class SumAggregator implements Aggregator { public kind: AggregatorKind.SUM = AggregatorKind.SUM; + public monotonic: boolean; - constructor(public monotonic: boolean) {} + constructor(monotonic: boolean) { + this.monotonic = monotonic; + } createAccumulation(startTime: HrTime) { return new SumAccumulation(startTime, this.monotonic); diff --git a/packages/sdk-metrics/src/aggregator/exponential-histogram/Buckets.ts b/packages/sdk-metrics/src/aggregator/exponential-histogram/Buckets.ts index 96ce0cc4bf8..8fa07317522 100644 --- a/packages/sdk-metrics/src/aggregator/exponential-histogram/Buckets.ts +++ b/packages/sdk-metrics/src/aggregator/exponential-histogram/Buckets.ts @@ -14,6 +14,10 @@ * limitations under the License. */ export class Buckets { + public backing; + public indexBase; + public indexStart; + public indexEnd; /** * The term index refers to the number of the exponential histogram bucket * used to determine its boundaries. The lower boundary of a bucket is @@ -32,11 +36,16 @@ export class Buckets { * the backing array. */ constructor( - public backing = new BucketsBacking(), - public indexBase = 0, - public indexStart = 0, - public indexEnd = 0 - ) {} + backing = new BucketsBacking(), + indexBase = 0, + indexStart = 0, + indexEnd = 0 + ) { + this.backing = backing; + this.indexBase = indexBase; + this.indexStart = indexStart; + this.indexEnd = indexEnd; + } /** * Offset is the bucket index of the smallest entry in the counts array @@ -216,7 +225,11 @@ export class Buckets { * manage them. */ class BucketsBacking { - constructor(private _counts = [0]) {} + private _counts; + + constructor(counts = [0]) { + this._counts = counts; + } /** * length returns the physical size of the backing array, which diff --git a/packages/sdk-metrics/src/state/AsyncMetricStorage.ts b/packages/sdk-metrics/src/state/AsyncMetricStorage.ts index 4f8651915a6..64da6a3ccde 100644 --- a/packages/sdk-metrics/src/state/AsyncMetricStorage.ts +++ b/packages/sdk-metrics/src/state/AsyncMetricStorage.ts @@ -36,17 +36,20 @@ export class AsyncMetricStorage> extends MetricStorage implements AsyncWritableMetricStorage { + private _aggregationCardinalityLimit?: number; private _deltaMetricStorage: DeltaMetricProcessor; private _temporalMetricStorage: TemporalMetricProcessor; + private _attributesProcessor: IAttributesProcessor; constructor( _instrumentDescriptor: InstrumentDescriptor, aggregator: Aggregator, - private _attributesProcessor: IAttributesProcessor, + attributesProcessor: IAttributesProcessor, collectorHandles: MetricCollectorHandle[], - private _aggregationCardinalityLimit?: number + aggregationCardinalityLimit?: number ) { super(_instrumentDescriptor); + this._aggregationCardinalityLimit = aggregationCardinalityLimit; this._deltaMetricStorage = new DeltaMetricProcessor( aggregator, this._aggregationCardinalityLimit @@ -55,6 +58,7 @@ export class AsyncMetricStorage> aggregator, collectorHandles ); + this._attributesProcessor = attributesProcessor; } record(measurements: AttributeHashMap, observationTime: HrTime) { diff --git a/packages/sdk-metrics/src/state/DeltaMetricProcessor.ts b/packages/sdk-metrics/src/state/DeltaMetricProcessor.ts index 926bbf952ff..38037326d2d 100644 --- a/packages/sdk-metrics/src/state/DeltaMetricProcessor.ts +++ b/packages/sdk-metrics/src/state/DeltaMetricProcessor.ts @@ -34,11 +34,10 @@ export class DeltaMetricProcessor> { private _cardinalityLimit: number; private _overflowAttributes = { 'otel.metric.overflow': true }; private _overflowHashCode: string; + private _aggregator: Aggregator; - constructor( - private _aggregator: Aggregator, - aggregationCardinalityLimit?: number - ) { + constructor(aggregator: Aggregator, aggregationCardinalityLimit?: number) { + this._aggregator = aggregator; this._cardinalityLimit = (aggregationCardinalityLimit ?? 2000) - 1; this._overflowHashCode = hashAttributes(this._overflowAttributes); } diff --git a/packages/sdk-metrics/src/state/HashMap.ts b/packages/sdk-metrics/src/state/HashMap.ts index 1036b66f77b..45594b9b403 100644 --- a/packages/sdk-metrics/src/state/HashMap.ts +++ b/packages/sdk-metrics/src/state/HashMap.ts @@ -24,8 +24,11 @@ export interface Hash { export class HashMap { private _valueMap = new Map(); private _keyMap = new Map(); + private _hash; - constructor(private _hash: Hash) {} + constructor(hash: Hash) { + this._hash = hash; + } get(key: KeyType, hashCode?: HashCodeType) { hashCode ??= this._hash(key); diff --git a/packages/sdk-metrics/src/state/MeterProviderSharedState.ts b/packages/sdk-metrics/src/state/MeterProviderSharedState.ts index 058cc62ca08..d5f438f830e 100644 --- a/packages/sdk-metrics/src/state/MeterProviderSharedState.ts +++ b/packages/sdk-metrics/src/state/MeterProviderSharedState.ts @@ -33,8 +33,11 @@ export class MeterProviderSharedState { metricCollectors: MetricCollector[] = []; meterSharedStates: Map = new Map(); + public resource: Resource; - constructor(public resource: Resource) {} + constructor(resource: Resource) { + this.resource = resource; + } getMeterSharedState(instrumentationScope: InstrumentationScope) { const id = instrumentationScopeId(instrumentationScope); diff --git a/packages/sdk-metrics/src/state/MeterSharedState.ts b/packages/sdk-metrics/src/state/MeterSharedState.ts index 824aa416620..b2115da7eb1 100644 --- a/packages/sdk-metrics/src/state/MeterSharedState.ts +++ b/packages/sdk-metrics/src/state/MeterSharedState.ts @@ -45,12 +45,16 @@ export class MeterSharedState { metricStorageRegistry = new MetricStorageRegistry(); observableRegistry = new ObservableRegistry(); meter: Meter; + private _meterProviderSharedState: MeterProviderSharedState; + private _instrumentationScope: InstrumentationScope; constructor( - private _meterProviderSharedState: MeterProviderSharedState, - private _instrumentationScope: InstrumentationScope + meterProviderSharedState: MeterProviderSharedState, + instrumentationScope: InstrumentationScope ) { this.meter = new Meter(this); + this._meterProviderSharedState = meterProviderSharedState; + this._instrumentationScope = instrumentationScope; } registerMetricStorage(descriptor: InstrumentDescriptor) { diff --git a/packages/sdk-metrics/src/state/MetricCollector.ts b/packages/sdk-metrics/src/state/MetricCollector.ts index 02faf0ae531..3755c148cdb 100644 --- a/packages/sdk-metrics/src/state/MetricCollector.ts +++ b/packages/sdk-metrics/src/state/MetricCollector.ts @@ -32,10 +32,16 @@ import { MeterProviderSharedState } from './MeterProviderSharedState'; * state for each MetricReader. */ export class MetricCollector implements MetricProducer { + private _sharedState: MeterProviderSharedState; + private _metricReader: IMetricReader; + constructor( - private _sharedState: MeterProviderSharedState, - private _metricReader: IMetricReader - ) {} + sharedState: MeterProviderSharedState, + metricReader: IMetricReader + ) { + this._sharedState = sharedState; + this._metricReader = metricReader; + } async collect(options?: MetricCollectOptions): Promise { const collectionTime = millisToHrTime(Date.now()); diff --git a/packages/sdk-metrics/src/state/MetricStorage.ts b/packages/sdk-metrics/src/state/MetricStorage.ts index e959ea0329c..a4a247194c6 100644 --- a/packages/sdk-metrics/src/state/MetricStorage.ts +++ b/packages/sdk-metrics/src/state/MetricStorage.ts @@ -29,7 +29,10 @@ import { * Represents a storage from which we can collect metrics. */ export abstract class MetricStorage { - constructor(protected _instrumentDescriptor: InstrumentDescriptor) {} + protected _instrumentDescriptor: InstrumentDescriptor; + constructor(instrumentDescriptor: InstrumentDescriptor) { + this._instrumentDescriptor = instrumentDescriptor; + } /** * Collects the metrics from this storage. diff --git a/packages/sdk-metrics/src/state/MultiWritableMetricStorage.ts b/packages/sdk-metrics/src/state/MultiWritableMetricStorage.ts index 9a60a0573cd..46697dd815f 100644 --- a/packages/sdk-metrics/src/state/MultiWritableMetricStorage.ts +++ b/packages/sdk-metrics/src/state/MultiWritableMetricStorage.ts @@ -21,7 +21,10 @@ import { WritableMetricStorage } from './WritableMetricStorage'; * Internal interface. */ export class MultiMetricStorage implements WritableMetricStorage { - constructor(private readonly _backingStorages: WritableMetricStorage[]) {} + private readonly _backingStorages: WritableMetricStorage[]; + constructor(backingStorages: WritableMetricStorage[]) { + this._backingStorages = backingStorages; + } record( value: number, diff --git a/packages/sdk-metrics/src/state/SyncMetricStorage.ts b/packages/sdk-metrics/src/state/SyncMetricStorage.ts index 10786c3dec7..e3fd953193c 100644 --- a/packages/sdk-metrics/src/state/SyncMetricStorage.ts +++ b/packages/sdk-metrics/src/state/SyncMetricStorage.ts @@ -35,17 +35,20 @@ export class SyncMetricStorage> extends MetricStorage implements WritableMetricStorage { + private _aggregationCardinalityLimit?: number; private _deltaMetricStorage: DeltaMetricProcessor; private _temporalMetricStorage: TemporalMetricProcessor; + private _attributesProcessor: IAttributesProcessor; constructor( instrumentDescriptor: InstrumentDescriptor, aggregator: Aggregator, - private _attributesProcessor: IAttributesProcessor, + attributesProcessor: IAttributesProcessor, collectorHandles: MetricCollectorHandle[], - private _aggregationCardinalityLimit?: number + aggregationCardinalityLimit?: number ) { super(instrumentDescriptor); + this._aggregationCardinalityLimit = aggregationCardinalityLimit; this._deltaMetricStorage = new DeltaMetricProcessor( aggregator, this._aggregationCardinalityLimit @@ -54,6 +57,7 @@ export class SyncMetricStorage> aggregator, collectorHandles ); + this._attributesProcessor = attributesProcessor; } record( diff --git a/packages/sdk-metrics/src/state/TemporalMetricProcessor.ts b/packages/sdk-metrics/src/state/TemporalMetricProcessor.ts index 967b6f81815..39bec6da33b 100644 --- a/packages/sdk-metrics/src/state/TemporalMetricProcessor.ts +++ b/packages/sdk-metrics/src/state/TemporalMetricProcessor.ts @@ -52,6 +52,7 @@ interface LastReportedHistory> { * of metrics and reports given temporality values. */ export class TemporalMetricProcessor> { + private _aggregator: Aggregator; private _unreportedAccumulations = new Map< MetricCollectorHandle, AttributeHashMap[] @@ -62,9 +63,10 @@ export class TemporalMetricProcessor> { >(); constructor( - private _aggregator: Aggregator, + aggregator: Aggregator, collectorHandles: MetricCollectorHandle[] ) { + this._aggregator = aggregator; collectorHandles.forEach(handle => { this._unreportedAccumulations.set(handle, []); }); diff --git a/packages/sdk-metrics/src/view/Aggregation.ts b/packages/sdk-metrics/src/view/Aggregation.ts index d256c238948..e1732132f28 100644 --- a/packages/sdk-metrics/src/view/Aggregation.ts +++ b/packages/sdk-metrics/src/view/Aggregation.ts @@ -98,15 +98,13 @@ export class HistogramAggregation implements Aggregation { */ export class ExplicitBucketHistogramAggregation implements Aggregation { private _boundaries: number[]; + private readonly _recordMinMax: boolean; /** * @param boundaries the bucket boundaries of the histogram aggregation * @param _recordMinMax If set to true, min and max will be recorded. Otherwise, min and max will not be recorded. */ - constructor( - boundaries: number[], - private readonly _recordMinMax = true - ) { + constructor(boundaries: number[], recordMinMax = true) { if (boundaries == null) { throw new Error( 'ExplicitBucketHistogramAggregation should be created with explicit boundaries, if a single bucket histogram is required, please pass an empty array' @@ -124,6 +122,7 @@ export class ExplicitBucketHistogramAggregation implements Aggregation { infinityIndex = undefined; } this._boundaries = boundaries.slice(minusInfinityIndex + 1, infinityIndex); + this._recordMinMax = recordMinMax; } createAggregator(_instrument: InstrumentDescriptor) { @@ -132,10 +131,13 @@ export class ExplicitBucketHistogramAggregation implements Aggregation { } export class ExponentialHistogramAggregation implements Aggregation { - constructor( - private readonly _maxSize = 160, - private readonly _recordMinMax = true - ) {} + private readonly _maxSize: number; + private readonly _recordMinMax: boolean; + + constructor(maxSize = 160, recordMinMax = true) { + this._maxSize = maxSize; + this._recordMinMax = recordMinMax; + } createAggregator(_instrument: InstrumentDescriptor) { return new ExponentialHistogramAggregator( this._maxSize, diff --git a/packages/sdk-metrics/src/view/AttributesProcessor.ts b/packages/sdk-metrics/src/view/AttributesProcessor.ts index 8ee58e31b9c..a1efd3ad2a0 100644 --- a/packages/sdk-metrics/src/view/AttributesProcessor.ts +++ b/packages/sdk-metrics/src/view/AttributesProcessor.ts @@ -39,7 +39,10 @@ class NoopAttributesProcessor implements IAttributesProcessor { } class MultiAttributesProcessor implements IAttributesProcessor { - constructor(private readonly _processors: IAttributesProcessor[]) {} + private readonly _processors: IAttributesProcessor[]; + constructor(processors: IAttributesProcessor[]) { + this._processors = processors; + } process(incoming: Attributes, context?: Context): Attributes { let filteredAttributes = incoming; for (const processor of this._processors) { @@ -50,7 +53,10 @@ class MultiAttributesProcessor implements IAttributesProcessor { } class AllowListProcessor implements IAttributesProcessor { - constructor(private _allowedAttributeNames: string[]) {} + private _allowedAttributeNames: string[]; + constructor(allowedAttributeNames: string[]) { + this._allowedAttributeNames = allowedAttributeNames; + } process(incoming: Attributes, _context?: Context): Attributes { const filteredAttributes: Attributes = {}; @@ -64,7 +70,10 @@ class AllowListProcessor implements IAttributesProcessor { } class DenyListProcessor implements IAttributesProcessor { - constructor(private _deniedAttributeNames: string[]) {} + private _deniedAttributeNames: string[]; + constructor(deniedAttributeNames: string[]) { + this._deniedAttributeNames = deniedAttributeNames; + } process(incoming: Attributes, _context?: Context): Attributes { const filteredAttributes: Attributes = {};