From 15e00a9cde70e6803f9903e0a247322a617e47d9 Mon Sep 17 00:00:00 2001 From: Aaron Abbott Date: Tue, 1 Aug 2023 05:42:23 +0000 Subject: [PATCH] feat(opencensus-shim): implement OpenCensus metric producer --- experimental/CHANGELOG.md | 2 + .../packages/shim-opencensus/package.json | 2 + .../src/OpenCensusMetricProducer.ts | 87 +++++ .../packages/shim-opencensus/src/ShimSpan.ts | 2 +- .../shim-opencensus/src/ShimTracer.ts | 2 +- .../shim-opencensus/src/metric-transform.ts | 210 ++++++++++++ .../shim-opencensus/src/propagation.ts | 2 +- .../src/{transform.ts => trace-transform.ts} | 0 .../test/OpenCensusMetricProducer.test.ts | 118 +++++++ .../test/metric-transform.test.ts | 321 ++++++++++++++++++ ...nsform.test.ts => trace-transform.test.ts} | 4 +- .../packages/shim-opencensus/tsconfig.json | 6 + 12 files changed, 751 insertions(+), 5 deletions(-) create mode 100644 experimental/packages/shim-opencensus/src/OpenCensusMetricProducer.ts create mode 100644 experimental/packages/shim-opencensus/src/metric-transform.ts rename experimental/packages/shim-opencensus/src/{transform.ts => trace-transform.ts} (100%) create mode 100644 experimental/packages/shim-opencensus/test/OpenCensusMetricProducer.test.ts create mode 100644 experimental/packages/shim-opencensus/test/metric-transform.test.ts rename experimental/packages/shim-opencensus/test/{transform.test.ts => trace-transform.test.ts} (98%) diff --git a/experimental/CHANGELOG.md b/experimental/CHANGELOG.md index 64b4debd388..4712a3d2bfb 100644 --- a/experimental/CHANGELOG.md +++ b/experimental/CHANGELOG.md @@ -10,6 +10,8 @@ All notable changes to experimental packages in this project will be documented ### :rocket: (Enhancement) +* feat(opencensus-shim): implement OpenCensus metric producer [#4066](https://github.com/open-telemetry/opentelemetry-js/pull/4066) + ### :bug: (Bug Fix) ### :books: (Refine Doc) diff --git a/experimental/packages/shim-opencensus/package.json b/experimental/packages/shim-opencensus/package.json index 3c9d4e82073..49c145724f5 100644 --- a/experimental/packages/shim-opencensus/package.json +++ b/experimental/packages/shim-opencensus/package.json @@ -70,6 +70,8 @@ }, "dependencies": { "@opentelemetry/core": "1.15.2", + "@opentelemetry/resources": "1.15.2", + "@opentelemetry/sdk-metrics": "1.15.2", "require-in-the-middle": "^7.1.1", "semver": "^7.5.1" }, diff --git a/experimental/packages/shim-opencensus/src/OpenCensusMetricProducer.ts b/experimental/packages/shim-opencensus/src/OpenCensusMetricProducer.ts new file mode 100644 index 00000000000..e75962e079f --- /dev/null +++ b/experimental/packages/shim-opencensus/src/OpenCensusMetricProducer.ts @@ -0,0 +1,87 @@ +/* + * 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. + */ + +import * as oc from '@opencensus/core'; +import { Resource } from '@opentelemetry/resources'; +import { + CollectionResult, + MetricData, + MetricProducer, + ScopeMetrics, +} from '@opentelemetry/sdk-metrics'; +import { mapOcMetric } from './metric-transform'; +import { VERSION } from './version'; + +const SCOPE = { + name: '@opentelemetry/shim-opencensus', + version: VERSION, +} as const; + +/** + * A {@link MetricProducer} which collects metrics from OpenCensus. Provide an instance to your + * {@link MetricReader} when you create it to include all OpenCensus metrics in the collection + * result: + * + * @example + * ``` + * const meterProvider = new MeterProvider(); + * const reader = new PeriodicExportingMetricReader({ + * metricProducers: [new OpenCensusMetricProducer()], + * exporter: exporter, + * }); + * meterProvider.addMetricReader(reader); + * ``` + */ +export class OpenCensusMetricProducer implements MetricProducer { + async collect(): Promise { + const metrics = await this._collectOpenCensus(); + const scopeMetrics: ScopeMetrics[] = + metrics.length === 0 + ? [] + : [ + { + scope: SCOPE, + metrics, + }, + ]; + + return { + errors: [], + resourceMetrics: { + // Resource is ignored by the SDK, it just uses the SDK's resource + resource: Resource.EMPTY, + scopeMetrics, + }, + }; + } + + private async _collectOpenCensus(): Promise { + const metrics: MetricData[] = []; + + // The use of oc.Metrics.getMetricProducerManager() was adapted from + // https://github.com/census-instrumentation/opencensus-node/blob/d46c8891b15783803d724b717db9a8c22cb73d6a/packages/opencensus-exporter-stackdriver/src/stackdriver-monitoring.ts#L122 + for (const metricProducer of oc.Metrics.getMetricProducerManager().getAllMetricProducer()) { + for (const metric of metricProducer.getMetrics()) { + const metricData = mapOcMetric(metric); + if (metricData !== null) { + metrics.push(metricData); + } + } + } + + return metrics; + } +} diff --git a/experimental/packages/shim-opencensus/src/ShimSpan.ts b/experimental/packages/shim-opencensus/src/ShimSpan.ts index 498c73e5e71..e4eaf47a2d3 100644 --- a/experimental/packages/shim-opencensus/src/ShimSpan.ts +++ b/experimental/packages/shim-opencensus/src/ShimSpan.ts @@ -17,7 +17,7 @@ import * as oc from '@opencensus/core'; import { ShimTracer } from './ShimTracer'; import { AttributeValue, Span, SpanStatusCode, diag } from '@opentelemetry/api'; -import { mapMessageEvent, reverseMapSpanContext } from './transform'; +import { mapMessageEvent, reverseMapSpanContext } from './trace-transform'; // Copied from // https://github.com/census-instrumentation/opencensus-node/blob/v0.1.0/packages/opencensus-core/src/trace/model/span.ts#L61 diff --git a/experimental/packages/shim-opencensus/src/ShimTracer.ts b/experimental/packages/shim-opencensus/src/ShimTracer.ts index f5e8164e3c6..c276b99e53e 100644 --- a/experimental/packages/shim-opencensus/src/ShimTracer.ts +++ b/experimental/packages/shim-opencensus/src/ShimTracer.ts @@ -26,7 +26,7 @@ import { Tracer, } from '@opentelemetry/api'; import { DEFAULT_SPAN_NAME, ShimSpan } from './ShimSpan'; -import { mapSpanContext, mapSpanKind } from './transform'; +import { mapSpanContext, mapSpanKind } from './trace-transform'; import { shimPropagation } from './propagation'; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion diff --git a/experimental/packages/shim-opencensus/src/metric-transform.ts b/experimental/packages/shim-opencensus/src/metric-transform.ts new file mode 100644 index 00000000000..54257f1f823 --- /dev/null +++ b/experimental/packages/shim-opencensus/src/metric-transform.ts @@ -0,0 +1,210 @@ +/* + * 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. + */ + +import * as oc from '@opencensus/core'; +import { Attributes, HrTime, ValueType, diag } from '@opentelemetry/api'; +import { + AggregationTemporality, + DataPoint, + DataPointType, + GaugeMetricData, + HistogramMetricData, + InstrumentType, + MetricData, + SumMetricData, +} from '@opentelemetry/sdk-metrics'; +import { FlatMap } from '@opentelemetry/sdk-metrics/src/utils'; + +type BaseMetric = Omit; +interface MappedType { + type: InstrumentType; + valueType: ValueType; + dataPointType: + | DataPointType.GAUGE + | DataPointType.SUM + | DataPointType.HISTOGRAM; +} +const ZEROED_HRTIME: HrTime = [0, 0]; + +export function mapOcMetric(metric: oc.Metric): MetricData | null { + const { description, name, unit, type } = metric.descriptor; + const mappedType = mapOcMetricDescriptorType(type); + if (mappedType === null) { + return null; + } + + const baseMetric: BaseMetric = { + aggregationTemporality: AggregationTemporality.CUMULATIVE, + descriptor: { + description, + name, + unit, + type: mappedType.type, + valueType: mappedType.valueType, + }, + }; + + switch (mappedType.dataPointType) { + case DataPointType.GAUGE: + return gauge(metric, mappedType.dataPointType, baseMetric); + case DataPointType.SUM: + return sum(metric, mappedType.dataPointType, baseMetric); + case DataPointType.HISTOGRAM: + return histogram(metric, mappedType.dataPointType, baseMetric); + } +} + +function mapOcMetricDescriptorType( + type: oc.MetricDescriptorType +): MappedType | null { + switch (type) { + case oc.MetricDescriptorType.GAUGE_INT64: + return { + type: InstrumentType.OBSERVABLE_GAUGE, + valueType: ValueType.INT, + dataPointType: DataPointType.GAUGE, + }; + case oc.MetricDescriptorType.GAUGE_DOUBLE: + return { + type: InstrumentType.OBSERVABLE_GAUGE, + valueType: ValueType.DOUBLE, + dataPointType: DataPointType.GAUGE, + }; + + case oc.MetricDescriptorType.CUMULATIVE_INT64: + return { + type: InstrumentType.COUNTER, + valueType: ValueType.INT, + dataPointType: DataPointType.SUM, + }; + case oc.MetricDescriptorType.CUMULATIVE_DOUBLE: + return { + type: InstrumentType.COUNTER, + valueType: ValueType.DOUBLE, + dataPointType: DataPointType.SUM, + }; + + case oc.MetricDescriptorType.CUMULATIVE_DISTRIBUTION: + return { + type: InstrumentType.HISTOGRAM, + valueType: ValueType.DOUBLE, + dataPointType: DataPointType.HISTOGRAM, + }; + + case oc.MetricDescriptorType.SUMMARY: + case oc.MetricDescriptorType.GAUGE_DISTRIBUTION: + case oc.MetricDescriptorType.UNSPECIFIED: + diag.warn( + 'Got unsupported metric MetricDescriptorType from OpenCensus: %s', + type + ); + return null; + } +} + +function gauge( + metric: oc.Metric, + dataPointType: DataPointType.GAUGE, + baseMetric: BaseMetric +): GaugeMetricData { + return { + ...baseMetric, + dataPoints: dataPoints(metric, value => value as number), + dataPointType, + }; +} + +function sum( + metric: oc.Metric, + dataPointType: DataPointType.SUM, + baseMetric: BaseMetric +): SumMetricData { + return { + ...baseMetric, + dataPoints: dataPoints(metric, value => value as number), + isMonotonic: true, + dataPointType, + }; +} + +function histogram( + metric: oc.Metric, + dataPointType: DataPointType.HISTOGRAM, + baseMetric: BaseMetric +): HistogramMetricData { + return { + ...baseMetric, + dataPoints: dataPoints(metric, value => { + const { + bucketOptions: { + explicit: { bounds }, + }, + buckets, + count, + sum: distSum, + } = value as oc.DistributionValue; + + return { + buckets: { + boundaries: bounds, + counts: buckets.map(bucket => bucket.count), + }, + count, + sum: distSum, + }; + }), + dataPointType, + }; +} + +function dataPoints( + metric: oc.Metric, + valueMapper: (value: oc.TimeSeriesPoint['value']) => T +): DataPoint[] { + return FlatMap(metric.timeseries, ts => { + const attributes = zipOcLabels(metric.descriptor.labelKeys, ts.labelValues); + + // use zeroed hrTime if it is undefined, which probably shouldn't happen + const startTime = ocTimestampToHrTime(ts.startTimestamp) ?? ZEROED_HRTIME; + + return ts.points.map( + (point): DataPoint => ({ + startTime, + attributes, + value: valueMapper(point.value), + endTime: ocTimestampToHrTime(point.timestamp) ?? ZEROED_HRTIME, + }) + ); + }); +} + +function ocTimestampToHrTime(ts: oc.Timestamp | undefined): HrTime | null { + if (ts === undefined || ts.seconds === null) { + return null; + } + return [ts.seconds, ts.nanos ?? 0]; +} + +function zipOcLabels( + labelKeys: oc.LabelKey[], + labelValues: oc.LabelValue[] +): Attributes { + const attributes: Attributes = {}; + for (let i = 0; i < labelKeys.length; i++) { + attributes[labelKeys[i].key] = labelValues[i].value ?? ''; + } + return attributes; +} diff --git a/experimental/packages/shim-opencensus/src/propagation.ts b/experimental/packages/shim-opencensus/src/propagation.ts index deb2509fa7b..e0045fe7d95 100644 --- a/experimental/packages/shim-opencensus/src/propagation.ts +++ b/experimental/packages/shim-opencensus/src/propagation.ts @@ -23,7 +23,7 @@ import { TextMapGetter, TextMapSetter, } from '@opentelemetry/api'; -import { mapSpanContext, reverseMapSpanContext } from './transform'; +import { mapSpanContext, reverseMapSpanContext } from './trace-transform'; class Getter implements TextMapGetter { constructor(private ocGetter: oc.HeaderGetter) {} diff --git a/experimental/packages/shim-opencensus/src/transform.ts b/experimental/packages/shim-opencensus/src/trace-transform.ts similarity index 100% rename from experimental/packages/shim-opencensus/src/transform.ts rename to experimental/packages/shim-opencensus/src/trace-transform.ts diff --git a/experimental/packages/shim-opencensus/test/OpenCensusMetricProducer.test.ts b/experimental/packages/shim-opencensus/test/OpenCensusMetricProducer.test.ts new file mode 100644 index 00000000000..15b9cc1a6be --- /dev/null +++ b/experimental/packages/shim-opencensus/test/OpenCensusMetricProducer.test.ts @@ -0,0 +1,118 @@ +/* + * 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. + */ + +import * as oc from '@opencensus/core'; +import { ValueType } from '@opentelemetry/api'; +import { Resource } from '@opentelemetry/resources'; +import { + AggregationTemporality, + DataPointType, + SumMetricData, +} from '@opentelemetry/sdk-metrics'; +import * as assert from 'assert'; +import * as sinon from 'sinon'; +import { OpenCensusMetricProducer } from '../src/OpenCensusMetricProducer'; + +describe('OpenCensusMetricProducer', () => { + beforeEach(() => { + oc.globalStats.clear(); + sinon.useFakeTimers(); + }); + + afterEach(() => { + sinon.restore(); + }); + + // Since the resource is replaced by the SDK anyway + it('should return an empty Resource', async () => { + const producer = new OpenCensusMetricProducer(); + const resourceMetrics = await producer.collect(); + + assert.deepStrictEqual( + resourceMetrics.resourceMetrics.resource, + Resource.EMPTY + ); + }); + + it('should return no errors when no metrics are collected from OpenCensus', async () => { + const producer = new OpenCensusMetricProducer(); + const resourceMetrics = await producer.collect(); + assert.strictEqual(resourceMetrics.errors.length, 0); + }); + + it('should elide the scope when no metrics are collected from OpenCensus', async () => { + // No OpenCensus setup so won't produce any metrics + const producer = new OpenCensusMetricProducer(); + const resourceMetrics = await producer.collect(); + assert.strictEqual(resourceMetrics.resourceMetrics.scopeMetrics.length, 0); + }); + + it('should include OpenCensus metrics', async () => { + // Initialize OC metrics with one counter, adapted from + // https://opencensus.io/quickstart/nodejs/metrics/ + const measure = oc.globalStats.createMeasureDouble( + 'measure', + oc.MeasureUnit.MS + ); + const tagKey = { name: 'label1' }; + oc.globalStats.registerView( + oc.globalStats.createView( + 'measure', + measure, + oc.AggregationType.SUM, + [tagKey], + 'Test OC description' + ) + ); + + const tagMap = new oc.TagMap(); + tagMap.set(tagKey, { value: 'tagvalue' }); + oc.globalStats.record([{ measure, value: 125 }], tagMap); + + const producer = new OpenCensusMetricProducer(); + const resourceMetrics = await producer.collect(); + + assert.strictEqual(resourceMetrics.errors.length, 0); + assert.strictEqual(resourceMetrics.resourceMetrics.scopeMetrics.length, 1); + assert.strictEqual( + resourceMetrics.resourceMetrics.scopeMetrics[0].scope.name, + '@opentelemetry/shim-opencensus' + ); + assert.strictEqual( + resourceMetrics.resourceMetrics.scopeMetrics[0].metrics.length, + 1 + ); + const ocMetric = resourceMetrics.resourceMetrics.scopeMetrics[0] + .metrics[0] as SumMetricData; + assert.deepStrictEqual(ocMetric.descriptor, { + description: 'Test OC description', + name: 'measure', + type: 'COUNTER', + unit: 'ms', + valueType: ValueType.DOUBLE, + }); + assert.strictEqual(ocMetric.dataPoints[0].value, 125); + assert.deepStrictEqual(ocMetric.dataPoints[0].attributes, { + label1: 'tagvalue', + }); + assert.strictEqual(ocMetric.dataPointType, DataPointType.SUM); + assert.strictEqual(ocMetric.isMonotonic, true); + assert.strictEqual( + ocMetric.aggregationTemporality, + AggregationTemporality.CUMULATIVE + ); + }); +}); diff --git a/experimental/packages/shim-opencensus/test/metric-transform.test.ts b/experimental/packages/shim-opencensus/test/metric-transform.test.ts new file mode 100644 index 00000000000..289fbefd0ce --- /dev/null +++ b/experimental/packages/shim-opencensus/test/metric-transform.test.ts @@ -0,0 +1,321 @@ +/* + * 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. + */ + +import { mapOcMetric } from '../src/metric-transform'; + +import * as oc from '@opencensus/core'; +import { ValueType } from '@opentelemetry/api'; +import { + AggregationTemporality, + DataPointType, + GaugeMetricData, + HistogramMetricData, + InstrumentType, + SumMetricData, +} from '@opentelemetry/sdk-metrics'; +import * as assert from 'assert'; + +describe('metric-transform', () => { + it('should map OpenCensus CUMULATIVE_INT64 to Sum', () => { + const metricData = mapOcMetric({ + descriptor: { + description: 'ocDescription', + name: 'ocMetricName', + type: oc.MetricDescriptorType.CUMULATIVE_INT64, + unit: 'ocUnit', + labelKeys: [ + { key: 'key1', description: '' }, + { key: 'key2', description: '' }, + ], + }, + timeseries: [ + { + startTimestamp: { seconds: 10, nanos: 10 }, + labelValues: [{ value: 'value1' }, { value: 'value2' }], + points: [{ timestamp: { seconds: 20, nanos: 20 }, value: 5 }], + }, + ], + }); + + assert.deepStrictEqual(metricData, { + aggregationTemporality: AggregationTemporality.CUMULATIVE, + dataPointType: DataPointType.SUM, + dataPoints: [ + { + attributes: { key1: 'value1', key2: 'value2' }, + endTime: [20, 20], + startTime: [10, 10], + value: 5, + }, + ], + descriptor: { + description: 'ocDescription', + name: 'ocMetricName', + type: InstrumentType.COUNTER, + unit: 'ocUnit', + valueType: ValueType.INT, + }, + isMonotonic: true, + } as SumMetricData); + }); + + it('should map OpenCensus CUMULATIVE_DOUBLE to Sum', () => { + const metricData = mapOcMetric({ + descriptor: { + description: 'ocDescription', + name: 'ocMetricName', + type: oc.MetricDescriptorType.CUMULATIVE_DOUBLE, + unit: 'ocUnit', + labelKeys: [ + { key: 'key1', description: '' }, + { key: 'key2', description: '' }, + ], + }, + timeseries: [ + { + startTimestamp: { seconds: 10, nanos: 10 }, + labelValues: [{ value: 'value1' }, { value: 'value2' }], + points: [{ timestamp: { seconds: 20, nanos: 20 }, value: 5.5 }], + }, + ], + }); + + assert.deepStrictEqual(metricData, { + aggregationTemporality: AggregationTemporality.CUMULATIVE, + dataPointType: DataPointType.SUM, + dataPoints: [ + { + attributes: { key1: 'value1', key2: 'value2' }, + endTime: [20, 20], + startTime: [10, 10], + value: 5.5, + }, + ], + descriptor: { + description: 'ocDescription', + name: 'ocMetricName', + type: InstrumentType.COUNTER, + unit: 'ocUnit', + valueType: ValueType.DOUBLE, + }, + isMonotonic: true, + } as SumMetricData); + }); + + it('should map OpenCensus CUMULATIVE_DISTRIBUTION to Histogram', () => { + const metricData = mapOcMetric({ + descriptor: { + description: 'ocDescription', + name: 'ocMetricName', + type: oc.MetricDescriptorType.CUMULATIVE_DISTRIBUTION, + unit: 'ocUnit', + labelKeys: [ + { key: 'key1', description: '' }, + { key: 'key2', description: '' }, + ], + }, + timeseries: [ + { + startTimestamp: { seconds: 10, nanos: 10 }, + labelValues: [{ value: 'value1' }, { value: 'value2' }], + points: [ + { + timestamp: { seconds: 20, nanos: 20 }, + value: { + bucketOptions: { + explicit: { + bounds: [1, 10, 100], + }, + }, + buckets: [ + { count: 0 }, + { count: 1 }, + { count: 2 }, + { count: 3 }, + ], + count: 6, + sum: 121, + sumOfSquaredDeviation: 4, + }, + }, + ], + }, + ], + }); + + assert.deepStrictEqual(metricData, { + aggregationTemporality: AggregationTemporality.CUMULATIVE, + dataPointType: DataPointType.HISTOGRAM, + dataPoints: [ + { + attributes: { key1: 'value1', key2: 'value2' }, + endTime: [20, 20], + startTime: [10, 10], + value: { + buckets: { + boundaries: [1, 10, 100], + counts: [0, 1, 2, 3], + }, + count: 6, + sum: 121, + }, + }, + ], + descriptor: { + description: 'ocDescription', + name: 'ocMetricName', + type: InstrumentType.HISTOGRAM, + unit: 'ocUnit', + valueType: ValueType.DOUBLE, + }, + } as HistogramMetricData); + }); + + it('should map OpenCensus GAUGE_INT64 to Gauge', () => { + const metricData = mapOcMetric({ + descriptor: { + description: 'ocDescription', + name: 'ocMetricName', + type: oc.MetricDescriptorType.GAUGE_INT64, + unit: 'ocUnit', + labelKeys: [ + { key: 'key1', description: '' }, + { key: 'key2', description: '' }, + ], + }, + timeseries: [ + { + startTimestamp: { seconds: 10, nanos: 10 }, + labelValues: [{ value: 'value1' }, { value: 'value2' }], + points: [{ timestamp: { seconds: 20, nanos: 20 }, value: 5 }], + }, + ], + }); + + assert.deepStrictEqual(metricData, { + aggregationTemporality: AggregationTemporality.CUMULATIVE, + dataPointType: DataPointType.GAUGE, + dataPoints: [ + { + attributes: { key1: 'value1', key2: 'value2' }, + endTime: [20, 20], + startTime: [10, 10], + value: 5, + }, + ], + descriptor: { + description: 'ocDescription', + name: 'ocMetricName', + type: InstrumentType.OBSERVABLE_GAUGE, + unit: 'ocUnit', + valueType: ValueType.INT, + }, + } as GaugeMetricData); + }); + + it('should map OpenCensus GAUGE_DOUBLE to Gauge', () => { + const metricData = mapOcMetric({ + descriptor: { + description: 'ocDescription', + name: 'ocMetricName', + type: oc.MetricDescriptorType.GAUGE_DOUBLE, + unit: 'ocUnit', + labelKeys: [ + { key: 'key1', description: '' }, + { key: 'key2', description: '' }, + ], + }, + timeseries: [ + { + startTimestamp: { seconds: 10, nanos: 10 }, + labelValues: [{ value: 'value1' }, { value: 'value2' }], + points: [{ timestamp: { seconds: 20, nanos: 20 }, value: 5.5 }], + }, + ], + }); + + assert.deepStrictEqual(metricData, { + aggregationTemporality: AggregationTemporality.CUMULATIVE, + dataPointType: DataPointType.GAUGE, + dataPoints: [ + { + attributes: { key1: 'value1', key2: 'value2' }, + endTime: [20, 20], + startTime: [10, 10], + value: 5.5, + }, + ], + descriptor: { + description: 'ocDescription', + name: 'ocMetricName', + type: InstrumentType.OBSERVABLE_GAUGE, + unit: 'ocUnit', + valueType: ValueType.DOUBLE, + }, + } as GaugeMetricData); + }); + + it('should drop unsupported OpenCensus GAUGE_DISTRIBUTION', () => { + const metricData = mapOcMetric({ + descriptor: { + description: 'ocDescription', + name: 'ocMetricName', + type: oc.MetricDescriptorType.GAUGE_DISTRIBUTION, + unit: 'ocUnit', + labelKeys: [ + { key: 'key1', description: '' }, + { key: 'key2', description: '' }, + ], + }, + timeseries: [ + { + startTimestamp: { seconds: 10, nanos: 10 }, + labelValues: [{ value: 'value1' }, { value: 'value2' }], + points: [{ timestamp: { seconds: 20, nanos: 20 }, value: 5 }], + }, + ], + }); + assert.deepStrictEqual(metricData, null); + }); + + it('should drop unsupported OpenCensus SUMMARY', () => { + const metricData = mapOcMetric({ + descriptor: { + description: 'ocDescription', + name: 'ocMetricName', + type: oc.MetricDescriptorType.SUMMARY, + unit: 'ocUnit', + labelKeys: [ + { key: 'key1', description: '' }, + { key: 'key2', description: '' }, + ], + }, + timeseries: [ + { + startTimestamp: { seconds: 10, nanos: 10 }, + labelValues: [{ value: 'value1' }, { value: 'value2' }], + points: [ + { + timestamp: { seconds: 20, nanos: 20 }, + value: { count: 5, sum: 10 }, + }, + ], + }, + ], + }); + assert.deepStrictEqual(metricData, null); + }); +}); diff --git a/experimental/packages/shim-opencensus/test/transform.test.ts b/experimental/packages/shim-opencensus/test/trace-transform.test.ts similarity index 98% rename from experimental/packages/shim-opencensus/test/transform.test.ts rename to experimental/packages/shim-opencensus/test/trace-transform.test.ts index 9a7f90cda05..6aacd5e951d 100644 --- a/experimental/packages/shim-opencensus/test/transform.test.ts +++ b/experimental/packages/shim-opencensus/test/trace-transform.test.ts @@ -19,14 +19,14 @@ import { mapSpanContext, mapSpanKind, reverseMapSpanContext, -} from '../src/transform'; +} from '../src/trace-transform'; import * as oc from '@opencensus/core'; import { SpanKind } from '@opentelemetry/api'; import { TraceState } from '@opentelemetry/core'; import * as assert from 'assert'; -describe('transform', () => { +describe('trace-transform', () => { describe('mapSpanKind', () => { it('should return undefined with undefined input', () => { assert.strictEqual(mapSpanKind(undefined), undefined); diff --git a/experimental/packages/shim-opencensus/tsconfig.json b/experimental/packages/shim-opencensus/tsconfig.json index 91cebb5ad54..145dd31760d 100644 --- a/experimental/packages/shim-opencensus/tsconfig.json +++ b/experimental/packages/shim-opencensus/tsconfig.json @@ -18,8 +18,14 @@ { "path": "../../../packages/opentelemetry-core" }, + { + "path": "../../../packages/opentelemetry-resources" + }, { "path": "../../../packages/opentelemetry-sdk-trace-base" + }, + { + "path": "../../../packages/sdk-metrics" } ] }