From 74db9a43f33fb7259658f4fc780130b17ff42c7b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Wed, 8 Mar 2023 06:33:26 +0000 Subject: [PATCH 01/16] feat(otlp-transformer): implement transformer for log records --- .../packages/otlp-transformer/.gitignore | 1 + .../packages/otlp-transformer/README.md | 13 +- .../packages/otlp-transformer/package.json | 8 +- .../packages/otlp-transformer/src/index.ts | 2 + .../otlp-transformer/src/logs/index.ts | 121 +++++++++++ .../otlp-transformer/src/logs/types.ts | 117 ++++++++++ .../otlp-transformer/test/logs.test.ts | 199 ++++++++++++++++++ .../otlp-transformer/test/trace.test.ts | 6 +- .../otlp-transformer/tsconfig.esm.json | 6 + .../otlp-transformer/tsconfig.esnext.json | 6 + .../packages/otlp-transformer/tsconfig.json | 6 + 11 files changed, 476 insertions(+), 9 deletions(-) create mode 100644 experimental/packages/otlp-transformer/src/logs/index.ts create mode 100644 experimental/packages/otlp-transformer/src/logs/types.ts create mode 100644 experimental/packages/otlp-transformer/test/logs.test.ts diff --git a/experimental/packages/otlp-transformer/.gitignore b/experimental/packages/otlp-transformer/.gitignore index c83f90a2b0..ae2d188110 100644 --- a/experimental/packages/otlp-transformer/.gitignore +++ b/experimental/packages/otlp-transformer/.gitignore @@ -1 +1,2 @@ src/generated +!src/logs \ No newline at end of file diff --git a/experimental/packages/otlp-transformer/README.md b/experimental/packages/otlp-transformer/README.md index e069aab559..b91b6d06d7 100644 --- a/experimental/packages/otlp-transformer/README.md +++ b/experimental/packages/otlp-transformer/README.md @@ -7,7 +7,7 @@ **Note: This is an experimental package under active development. New releases may include breaking changes.** -This package provides everything needed to serialize [OpenTelemetry SDK][sdk] traces and metrics into the [OpenTelemetry Protocol][otlp] format. +This package provides everything needed to serialize [OpenTelemetry SDK][sdk] traces, metrics and logs into the [OpenTelemetry Protocol][otlp] format. ## Quick Start @@ -19,15 +19,20 @@ To get started you will need to install a compatible OpenTelemetry API. npm install @opentelemetry/api ``` -### Serialize Traces and Metrics +### Serialize Traces/Metrics/Logs -This module exports functions to serialize traces and metrics from the OpenTelemetry SDK into protocol buffers which can be sent over HTTP to the OpenTelemetry collector or a compatible receiver. +This module exports functions to serialize traces, metrics and logs from the OpenTelemetry SDK into protocol buffers which can be sent over HTTP to the OpenTelemetry collector or a compatible receiver. ```typescript -import { createExportTraceServiceRequest, createExportMetricsServiceRequest } from "@opentelemetry/otlp-transformer"; +import { + createExportTraceServiceRequest, + createExportMetricsServiceRequest, + createExportLogsServiceRequest, +} from '@opentelemetry/otlp-transformer'; const serializedSpans = createExportTraceServiceRequest(readableSpans); const serializedMetrics = createExportMetricsServiceRequest(readableMetrics); +const serializedLogs = createExportLogsServiceRequest(readableLogRecords); ``` ## Useful links diff --git a/experimental/packages/otlp-transformer/package.json b/experimental/packages/otlp-transformer/package.json index 89fa62c17d..f5395a7ef0 100644 --- a/experimental/packages/otlp-transformer/package.json +++ b/experimental/packages/otlp-transformer/package.json @@ -52,10 +52,14 @@ "README.md" ], "peerDependencies": { - "@opentelemetry/api": ">=1.3.0 <1.5.0" + "@opentelemetry/api": ">=1.3.0 <1.5.0", + "@opentelemetry/api-logs": "0.38.0", + "@opentelemetry/sdk-logs": "0.38.0" }, "devDependencies": { "@opentelemetry/api": "1.4.1", + "@opentelemetry/api-logs": "0.38.0", + "@opentelemetry/sdk-logs": "0.38.0", "@types/mocha": "10.0.0", "@types/webpack-env": "1.16.3", "codecov": "3.8.3", @@ -81,4 +85,4 @@ }, "homepage": "https://github.com/open-telemetry/opentelemetry-js/tree/main/experimental/packages/otlp-transformer", "sideEffects": false -} +} \ No newline at end of file diff --git a/experimental/packages/otlp-transformer/src/index.ts b/experimental/packages/otlp-transformer/src/index.ts index 51408c10d8..a8e388e33a 100644 --- a/experimental/packages/otlp-transformer/src/index.ts +++ b/experimental/packages/otlp-transformer/src/index.ts @@ -18,6 +18,8 @@ export * from './common/types'; export * from './metrics/types'; export * from './resource/types'; export * from './trace/types'; +export * from './logs/types'; export { createExportTraceServiceRequest } from './trace'; export { createExportMetricsServiceRequest } from './metrics'; +export { createExportLogsServiceRequest } from './logs'; diff --git a/experimental/packages/otlp-transformer/src/logs/index.ts b/experimental/packages/otlp-transformer/src/logs/index.ts new file mode 100644 index 0000000000..4fd114fa69 --- /dev/null +++ b/experimental/packages/otlp-transformer/src/logs/index.ts @@ -0,0 +1,121 @@ +/* + * 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 type { ReadableLogRecord } from '@opentelemetry/sdk-logs'; +import { + ESeverityNumber, + IExportLogsServiceRequest, + ILogRecord, + IResourceLogs, +} from './types'; +import { IResource } from '@opentelemetry/resources'; +import { toAnyValue, toAttributes } from '../common/internal'; +import { hexToBase64, hrTimeToNanoseconds } from '@opentelemetry/core'; +import { SeverityNumber } from '@opentelemetry/api-logs'; + +export function createExportLogsServiceRequest( + logRecords: ReadableLogRecord[], + useHex?: boolean +): IExportLogsServiceRequest { + return { + resourceLogs: logRecordsToResourceLogs(logRecords, useHex), + }; +} + +function createResourceMap( + logRecords: ReadableLogRecord[] +): Map> { + const resourceMap: Map< + IResource, + Map + > = new Map(); + + for (const record of logRecords) { + const { + resource, + instrumentationScope: { name, version = '', schemaUrl = '' }, + } = record; + + let ismMap = resourceMap.get(resource); + if (!ismMap) { + ismMap = new Map(); + resourceMap.set(resource, ismMap); + } + + const ismKey = `${name}@${version}:${schemaUrl}`; + let records = ismMap.get(ismKey); + if (!records) { + records = []; + ismMap.set(ismKey, records); + } + records.push(record); + } + return resourceMap; +} + +function logRecordsToResourceLogs( + logRecords: ReadableLogRecord[], + useHex?: boolean +): IResourceLogs[] { + const resourceMap = createResourceMap(logRecords); + return Array.from(resourceMap, ([resource, ismMap]) => ({ + resource: { + attributes: toAttributes(resource.attributes), + droppedAttributesCount: 0, + }, + scopeLogs: Array.from(ismMap, ([, scopeLogs]) => { + const { + instrumentationScope: { name, version, schemaUrl }, + } = scopeLogs[0]; + return { + scope: { name, version }, + logRecords: scopeLogs.map(log => toLogRecord(log, useHex)), + schemaUrl, + }; + }), + schemaUrl: undefined, + })); +} + +function toLogRecord(log: ReadableLogRecord, useHex?: boolean): ILogRecord { + return { + timeUnixNano: hrTimeToNanoseconds(log.hrTime), + observedTimeUnixNano: hrTimeToNanoseconds(log.hrTime), + severityNumber: toSeverityNumber(log.severityNumber), + severityText: log.severityText, + body: toAnyValue(log.body), + attributes: toAttributes(log.attributes), + droppedAttributesCount: 0, + flags: log.spanContext?.traceFlags, + traceId: useHex + ? log.spanContext?.traceId + : optionalHexToBase64(log.spanContext?.traceId), + spanId: useHex + ? log.spanContext?.spanId + : optionalHexToBase64(log.spanContext?.spanId), + }; +} + +function toSeverityNumber( + severityNumber: SeverityNumber | undefined +): ESeverityNumber | undefined { + return severityNumber as number | undefined as ESeverityNumber | undefined; +} + +function optionalHexToBase64(str: string | undefined): string | undefined { + if (str === undefined) return undefined; + return hexToBase64(str); +} diff --git a/experimental/packages/otlp-transformer/src/logs/types.ts b/experimental/packages/otlp-transformer/src/logs/types.ts new file mode 100644 index 0000000000..3d3e610bc7 --- /dev/null +++ b/experimental/packages/otlp-transformer/src/logs/types.ts @@ -0,0 +1,117 @@ +/* + * 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 type { + IAnyValue, + IInstrumentationScope, + IKeyValue, +} from '../common/types'; +import type { IResource } from '../resource/types'; + +/** Properties of an ExportLogsServiceRequest. */ +export interface IExportLogsServiceRequest { + /** ExportLogsServiceRequest resourceLogs */ + resourceLogs?: IResourceLogs[]; +} + +/** Properties of a ResourceLogs. */ +export interface IResourceLogs { + /** ResourceLogs resource */ + resource?: IResource; + + /** ResourceLogs scopeLogs */ + scopeLogs: IScopeLogs[]; + + /** ResourceLogs schemaUrl */ + schemaUrl?: string; +} + +/** Properties of an ScopeLogs. */ +export interface IScopeLogs { + /** IScopeLogs scope */ + scope?: IInstrumentationScope; + + /** IScopeLogs logRecords */ + logRecords?: ILogRecord[]; + + /** IScopeLogs schemaUrl */ + schemaUrl?: string | null; +} + +/** Properties of a LogRecord. */ +export interface ILogRecord { + /** LogRecord timeUnixNano */ + timeUnixNano: number; + + /** LogRecord observedTimeUnixNano */ + observedTimeUnixNano: number; + + /** LogRecord severityNumber */ + severityNumber?: ESeverityNumber; + + /** LogRecord severityText */ + severityText?: string; + + /** LogRecord body */ + body?: IAnyValue; + + /** LogRecord attributes */ + attributes: IKeyValue[]; + + /** LogRecord droppedAttributesCount */ + droppedAttributesCount: number; + + /** LogRecord flags */ + flags?: number; + + /** LogRecord traceId */ + traceId?: string; + + /** LogRecord spanId */ + spanId?: string; +} + +/** + * Numerical value of the severity, normalized to values described in Log Data Model. + */ +export const enum ESeverityNumber { + /** Unspecified. Do NOT use as default */ + SEVERITY_NUMBER_UNSPECIFIED = 0, + SEVERITY_NUMBER_TRACE = 1, + SEVERITY_NUMBER_TRACE2 = 2, + SEVERITY_NUMBER_TRACE3 = 3, + SEVERITY_NUMBER_TRACE4 = 4, + SEVERITY_NUMBER_DEBUG = 5, + SEVERITY_NUMBER_DEBUG2 = 6, + SEVERITY_NUMBER_DEBUG3 = 7, + SEVERITY_NUMBER_DEBUG4 = 8, + SEVERITY_NUMBER_INFO = 9, + SEVERITY_NUMBER_INFO2 = 10, + SEVERITY_NUMBER_INFO3 = 11, + SEVERITY_NUMBER_INFO4 = 12, + SEVERITY_NUMBER_WARN = 13, + SEVERITY_NUMBER_WARN2 = 14, + SEVERITY_NUMBER_WARN3 = 15, + SEVERITY_NUMBER_WARN4 = 16, + SEVERITY_NUMBER_ERROR = 17, + SEVERITY_NUMBER_ERROR2 = 18, + SEVERITY_NUMBER_ERROR3 = 19, + SEVERITY_NUMBER_ERROR4 = 20, + SEVERITY_NUMBER_FATAL = 21, + SEVERITY_NUMBER_FATAL2 = 22, + SEVERITY_NUMBER_FATAL3 = 23, + SEVERITY_NUMBER_FATAL4 = 24, +} diff --git a/experimental/packages/otlp-transformer/test/logs.test.ts b/experimental/packages/otlp-transformer/test/logs.test.ts new file mode 100644 index 0000000000..c184134ce4 --- /dev/null +++ b/experimental/packages/otlp-transformer/test/logs.test.ts @@ -0,0 +1,199 @@ +/* + * 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 { HrTime, TraceFlags } from '@opentelemetry/api'; +import { InstrumentationScope, hexToBase64 } from '@opentelemetry/core'; +import { Resource } from '@opentelemetry/resources'; +import * as assert from 'assert'; +import { + createExportLogsServiceRequest, + ESeverityNumber, + IExportLogsServiceRequest, +} from '../src'; +import { ReadableLogRecord } from '@opentelemetry/sdk-logs'; +import { SeverityNumber } from '@opentelemetry/api-logs'; + +function createExpectedLogJson(useHex: boolean): IExportLogsServiceRequest { + const traceId = useHex + ? '00000000000000000000000000000001' + : hexToBase64('00000000000000000000000000000001'); + const spanId = useHex ? '0000000000000002' : hexToBase64('0000000000000002'); + + return { + resourceLogs: [ + { + resource: { + attributes: [ + { + key: 'resource-attribute', + value: { stringValue: 'some attribute value' }, + }, + ], + droppedAttributesCount: 0, + }, + schemaUrl: undefined, + scopeLogs: [ + { + scope: { name: 'scope_name_1', version: '0.1.0' }, + logRecords: [ + { + // eslint-disable-next-line @typescript-eslint/no-loss-of-precision + timeUnixNano: 1680253513123241635, + // eslint-disable-next-line @typescript-eslint/no-loss-of-precision + observedTimeUnixNano: 1680253513123241635, + severityNumber: ESeverityNumber.SEVERITY_NUMBER_ERROR, + severityText: 'error', + body: { stringValue: 'some_log_body' }, + + attributes: [ + { + key: 'some-attribute', + value: { stringValue: 'some attribute value' }, + }, + ], + droppedAttributesCount: 0, + flags: 1, + traceId: traceId, + spanId: spanId, + }, + ], + schemaUrl: 'http://url.to.schema', + }, + ], + }, + ], + }; +} + +describe('Logs', () => { + describe('createExportLogsServiceRequest', () => { + let resource_1: Resource; + let resource_2: Resource; + let scope_1: InstrumentationScope; + let scope_2: InstrumentationScope; + let log_1_1_1: ReadableLogRecord; + let log_1_1_2: ReadableLogRecord; + let log_1_2_1: ReadableLogRecord; + let log_2_1_1: ReadableLogRecord; + + beforeEach(() => { + resource_1 = new Resource({ + 'resource-attribute': 'some attribute value', + }); + resource_2 = new Resource({ + 'resource-attribute': 'another attribute value', + }); + scope_1 = { + name: 'scope_name_1', + version: '0.1.0', + schemaUrl: 'http://url.to.schema', + }; + scope_2 = { + name: 'scope_name_2', + }; + const log_fragment_1 = { + hrTime: [1680253513, 123241635] as HrTime, + attributes: { + 'some-attribute': 'some attribute value', + }, + severityNumber: SeverityNumber.ERROR, + severityText: 'error', + body: 'some_log_body', + spanContext: { + spanId: '0000000000000002', + traceFlags: TraceFlags.SAMPLED, + traceId: '00000000000000000000000000000001', + }, + }; + const log_fragment_2 = { + hrTime: [1680253797, 687038506] as HrTime, + attributes: { + 'another-attribute': 'another attribute value', + }, + }; + log_1_1_1 = { + ...log_fragment_1, + resource: resource_1, + instrumentationScope: scope_1, + }; + log_1_1_2 = { + ...log_fragment_2, + resource: resource_1, + instrumentationScope: scope_1, + }; + log_1_2_1 = { + ...log_fragment_1, + resource: resource_1, + instrumentationScope: scope_2, + }; + log_2_1_1 = { + ...log_fragment_1, + resource: resource_2, + instrumentationScope: scope_1, + }; + }); + + it('returns null on an empty list', () => { + assert.deepStrictEqual(createExportLogsServiceRequest([], true), { + resourceLogs: [], + }); + }); + + it('serializes a log record with useHex = true', () => { + const exportRequest = createExportLogsServiceRequest([log_1_1_1], true); + assert.ok(exportRequest); + assert.deepStrictEqual(exportRequest, createExpectedLogJson(true)); + }); + + it('serializes a log record with useHex = false', () => { + const exportRequest = createExportLogsServiceRequest([log_1_1_1], false); + assert.ok(exportRequest); + assert.deepStrictEqual(exportRequest, createExpectedLogJson(false)); + }); + + it('aggregates multiple logs with same resource and same scope', () => { + const exportRequest = createExportLogsServiceRequest( + [log_1_1_1, log_1_1_2], + false + ); + assert.ok(exportRequest); + assert.strictEqual(exportRequest.resourceLogs?.length, 1); + assert.strictEqual(exportRequest.resourceLogs?.[0].scopeLogs.length, 1); + assert.strictEqual( + exportRequest.resourceLogs?.[0].scopeLogs?.[0].logRecords?.length, + 2 + ); + }); + + it('aggregates multiple logs with same resource and different scopes', () => { + const exportRequest = createExportLogsServiceRequest( + [log_1_1_1, log_1_2_1], + false + ); + assert.ok(exportRequest); + assert.strictEqual(exportRequest.resourceLogs?.length, 1); + assert.strictEqual(exportRequest.resourceLogs?.[0].scopeLogs.length, 2); + }); + + it('aggregates multiple logs with different resources', () => { + const exportRequest = createExportLogsServiceRequest( + [log_1_1_1, log_2_1_1], + false + ); + assert.ok(exportRequest); + assert.strictEqual(exportRequest.resourceLogs?.length, 2); + }); + }); +}); diff --git a/experimental/packages/otlp-transformer/test/trace.test.ts b/experimental/packages/otlp-transformer/test/trace.test.ts index da3e1d0c7d..9fb0e3cbfb 100644 --- a/experimental/packages/otlp-transformer/test/trace.test.ts +++ b/experimental/packages/otlp-transformer/test/trace.test.ts @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import { SpanKind, SpanStatusCode } from '@opentelemetry/api'; +import { SpanKind, SpanStatusCode, TraceFlags } from '@opentelemetry/api'; import { TraceState, hexToBase64 } from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; import { ReadableSpan } from '@opentelemetry/sdk-trace-base'; @@ -133,7 +133,7 @@ describe('Trace', () => { span = { spanContext: () => ({ spanId: '0000000000000002', - traceFlags: 1, + traceFlags: TraceFlags.SAMPLED, traceId: '00000000000000000000000000000001', isRemote: false, traceState: new TraceState('span=bar'), @@ -163,7 +163,7 @@ describe('Trace', () => { context: { spanId: '0000000000000003', traceId: '00000000000000000000000000000002', - traceFlags: 1, + traceFlags: TraceFlags.SAMPLED, isRemote: false, traceState: new TraceState('link=foo'), }, diff --git a/experimental/packages/otlp-transformer/tsconfig.esm.json b/experimental/packages/otlp-transformer/tsconfig.esm.json index ec36d4d115..0dc676825c 100644 --- a/experimental/packages/otlp-transformer/tsconfig.esm.json +++ b/experimental/packages/otlp-transformer/tsconfig.esm.json @@ -23,6 +23,12 @@ }, { "path": "../../../packages/sdk-metrics" + }, + { + "path": "../api-logs" + }, + { + "path": "../sdk-logs" } ] } diff --git a/experimental/packages/otlp-transformer/tsconfig.esnext.json b/experimental/packages/otlp-transformer/tsconfig.esnext.json index 5c344c8861..56f7465ceb 100644 --- a/experimental/packages/otlp-transformer/tsconfig.esnext.json +++ b/experimental/packages/otlp-transformer/tsconfig.esnext.json @@ -23,6 +23,12 @@ }, { "path": "../../../packages/sdk-metrics" + }, + { + "path": "../api-logs" + }, + { + "path": "../sdk-logs" } ] } diff --git a/experimental/packages/otlp-transformer/tsconfig.json b/experimental/packages/otlp-transformer/tsconfig.json index 88d7f2d5ab..cb92fea575 100644 --- a/experimental/packages/otlp-transformer/tsconfig.json +++ b/experimental/packages/otlp-transformer/tsconfig.json @@ -24,6 +24,12 @@ }, { "path": "../../../packages/sdk-metrics" + }, + { + "path": "../api-logs" + }, + { + "path": "../sdk-logs" } ] } From 9d87fd9ad664ba4333d5463f3daa502d75342e69 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Wed, 8 Mar 2023 16:25:12 +0800 Subject: [PATCH 02/16] refactor(otlp-transformer): rename `SpanAttributes` to `Attributes` --- .../packages/otlp-transformer/src/common/internal.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/experimental/packages/otlp-transformer/src/common/internal.ts b/experimental/packages/otlp-transformer/src/common/internal.ts index a5ba7f3c2d..623297cbf6 100644 --- a/experimental/packages/otlp-transformer/src/common/internal.ts +++ b/experimental/packages/otlp-transformer/src/common/internal.ts @@ -13,10 +13,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -import type { SpanAttributes } from '@opentelemetry/api'; -import { IAnyValue, IKeyValue } from './types'; +import type { Attributes } from '@opentelemetry/api'; +import type { IAnyValue, IKeyValue } from './types'; -export function toAttributes(attributes: SpanAttributes): IKeyValue[] { +export function toAttributes(attributes: Attributes): IKeyValue[] { return Object.keys(attributes).map(key => toKeyValue(key, attributes[key])); } From 3e41f0f38233626f89612bfdae3c3eb038159a79 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Fri, 31 Mar 2023 17:42:25 +0800 Subject: [PATCH 03/16] refactor(otlp-transformer): remove unused internal functions --- .../otlp-transformer/src/common/internal.ts | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/experimental/packages/otlp-transformer/src/common/internal.ts b/experimental/packages/otlp-transformer/src/common/internal.ts index 623297cbf6..5612b87ce9 100644 --- a/experimental/packages/otlp-transformer/src/common/internal.ts +++ b/experimental/packages/otlp-transformer/src/common/internal.ts @@ -49,17 +49,3 @@ export function toAnyValue(value: unknown): IAnyValue { return {}; } - -export function hexToBuf(hex: string): Uint8Array | undefined { - const ints = hex.match(/[\da-f]{2}/gi)?.map(h => parseInt(h, 16)); - return ints && new Uint8Array(ints); -} - -function i2hex(i: number): string { - return ('0' + i.toString(16)).slice(-2); -} - -export function bufToHex(buf?: Uint8Array | null): string | undefined { - if (buf == null || buf.length === 0) return undefined; - return Array.from(buf).map(i2hex).join(''); -} From fdd06c6ff97bc8c16c716bdaae8f86a52137940a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Fri, 31 Mar 2023 18:06:36 +0800 Subject: [PATCH 04/16] refactor(otlp-transformer): improve code coverage for metrics --- .../otlp-transformer/src/metrics/internal.ts | 91 ++++++++++--------- 1 file changed, 46 insertions(+), 45 deletions(-) diff --git a/experimental/packages/otlp-transformer/src/metrics/internal.ts b/experimental/packages/otlp-transformer/src/metrics/internal.ts index 7ba7722b6a..b73696b0ab 100644 --- a/experimental/packages/otlp-transformer/src/metrics/internal.ts +++ b/experimental/packages/otlp-transformer/src/metrics/internal.ts @@ -44,24 +44,21 @@ export function toResourceMetrics( attributes: toAttributes(resourceMetrics.resource.attributes), droppedAttributesCount: 0, }, - schemaUrl: undefined, // TODO: Schema Url does not exist yet in the SDK. + schemaUrl: undefined, scopeMetrics: toScopeMetrics(resourceMetrics.scopeMetrics), }; } export function toScopeMetrics(scopeMetrics: ScopeMetrics[]): IScopeMetrics[] { return Array.from( - scopeMetrics.map(metrics => { - const scopeMetrics: IScopeMetrics = { - scope: { - name: metrics.scope.name, - version: metrics.scope.version, - }, - metrics: metrics.metrics.map(metricData => toMetric(metricData)), - schemaUrl: metrics.scope.schemaUrl, - }; - return scopeMetrics; - }) + scopeMetrics.map(metrics => ({ + scope: { + name: metrics.scope.name, + version: metrics.scope.version, + }, + metrics: metrics.metrics.map(metricData => toMetric(metricData)), + schemaUrl: metrics.scope.schemaUrl, + })) ); } @@ -76,27 +73,31 @@ export function toMetric(metricData: MetricData): IMetric { metricData.aggregationTemporality ); - if (metricData.dataPointType === DataPointType.SUM) { - out.sum = { - aggregationTemporality, - isMonotonic: metricData.isMonotonic, - dataPoints: toSingularDataPoints(metricData), - }; - } else if (metricData.dataPointType === DataPointType.GAUGE) { - // Instrument is a gauge. - out.gauge = { - dataPoints: toSingularDataPoints(metricData), - }; - } else if (metricData.dataPointType === DataPointType.HISTOGRAM) { - out.histogram = { - aggregationTemporality, - dataPoints: toHistogramDataPoints(metricData), - }; - } else if (metricData.dataPointType === DataPointType.EXPONENTIAL_HISTOGRAM) { - out.exponentialHistogram = { - aggregationTemporality, - dataPoints: toExponentialHistogramDataPoints(metricData), - }; + switch (metricData.dataPointType) { + case DataPointType.SUM: + out.sum = { + aggregationTemporality, + isMonotonic: metricData.isMonotonic, + dataPoints: toSingularDataPoints(metricData), + }; + break; + case DataPointType.GAUGE: + out.gauge = { + dataPoints: toSingularDataPoints(metricData), + }; + break; + case DataPointType.HISTOGRAM: + out.histogram = { + aggregationTemporality, + dataPoints: toHistogramDataPoints(metricData), + }; + break; + case DataPointType.EXPONENTIAL_HISTOGRAM: + out.exponentialHistogram = { + aggregationTemporality, + dataPoints: toExponentialHistogramDataPoints(metricData), + }; + break; } return out; @@ -115,10 +116,13 @@ function toSingularDataPoint( timeUnixNano: hrTimeToNanoseconds(dataPoint.endTime), }; - if (valueType === ValueType.INT) { - out.asInt = dataPoint.value as number; - } else if (valueType === ValueType.DOUBLE) { - out.asDouble = dataPoint.value as number; + switch (valueType) { + case ValueType.INT: + out.asInt = dataPoint.value as number; + break; + case ValueType.DOUBLE: + out.asDouble = dataPoint.value as number; + break; } return out; @@ -177,13 +181,10 @@ function toExponentialHistogramDataPoints( function toAggregationTemporality( temporality: AggregationTemporality ): EAggregationTemporality { - if (temporality === AggregationTemporality.DELTA) { - return EAggregationTemporality.AGGREGATION_TEMPORALITY_DELTA; + switch (temporality) { + case AggregationTemporality.DELTA: + return EAggregationTemporality.AGGREGATION_TEMPORALITY_DELTA; + case AggregationTemporality.CUMULATIVE: + return EAggregationTemporality.AGGREGATION_TEMPORALITY_CUMULATIVE; } - - if (temporality === AggregationTemporality.CUMULATIVE) { - return EAggregationTemporality.AGGREGATION_TEMPORALITY_CUMULATIVE; - } - - return EAggregationTemporality.AGGREGATION_TEMPORALITY_UNSPECIFIED; } From 3a93e48d4274ec1ad42fcadbe496fa9473eb4145 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Wed, 8 Mar 2023 05:02:00 +0000 Subject: [PATCH 05/16] feat(otel-grpc-exporter-base): support LogsService --- .../otlp-grpc-exporter-base/src/types.ts | 5 ++- .../otlp-grpc-exporter-base/src/util.ts | 39 ++++++++++++------- 2 files changed, 28 insertions(+), 16 deletions(-) diff --git a/experimental/packages/otlp-grpc-exporter-base/src/types.ts b/experimental/packages/otlp-grpc-exporter-base/src/types.ts index fa3fea4ab1..af67188846 100644 --- a/experimental/packages/otlp-grpc-exporter-base/src/types.ts +++ b/experimental/packages/otlp-grpc-exporter-base/src/types.ts @@ -22,7 +22,7 @@ import { } from '@opentelemetry/otlp-exporter-base'; /** - * Queue item to be used to save temporary spans/metrics in case the GRPC service + * Queue item to be used to save temporary spans/metrics/logs in case the GRPC service * hasn't been fully initialized yet */ export interface GRPCQueueItem { @@ -32,7 +32,7 @@ export interface GRPCQueueItem { } /** - * Service Client for sending spans or metrics + * Service Client for sending spans/metrics/logs */ export interface ServiceClient extends grpc.Client { export: ( @@ -55,4 +55,5 @@ export interface OTLPGRPCExporterConfigNode extends OTLPExporterConfigBase { export enum ServiceClientType { SPANS, METRICS, + LOGS, } diff --git a/experimental/packages/otlp-grpc-exporter-base/src/util.ts b/experimental/packages/otlp-grpc-exporter-base/src/util.ts index 9a42327167..f4dc8af8a9 100644 --- a/experimental/packages/otlp-grpc-exporter-base/src/util.ts +++ b/experimental/packages/otlp-grpc-exporter-base/src/util.ts @@ -64,20 +64,31 @@ export function onInit( 'grpc.default_compression_algorithm': collector.compression, }; - if (collector.getServiceClientType() === ServiceClientType.SPANS) { - collector.serviceClient = - new packageObject.opentelemetry.proto.collector.trace.v1.TraceService( - collector.url, - credentials, - options - ); - } else { - collector.serviceClient = - new packageObject.opentelemetry.proto.collector.metrics.v1.MetricsService( - collector.url, - credentials, - options - ); + switch (collector.getServiceClientType()) { + case ServiceClientType.SPANS: + collector.serviceClient = + new packageObject.opentelemetry.proto.collector.trace.v1.TraceService( + collector.url, + credentials, + options + ); + break; + case ServiceClientType.METRICS: + collector.serviceClient = + new packageObject.opentelemetry.proto.collector.metrics.v1.MetricsService( + collector.url, + credentials, + options + ); + break; + case ServiceClientType.LOGS: + collector.serviceClient = + new packageObject.opentelemetry.proto.collector.logs.v1.LogsService( + collector.url, + credentials, + options + ); + break; } if (collector.grpcQueue.length > 0) { From 11ec67d774a5979b6c3f1562eefbaf93e04e6477 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Mon, 3 Apr 2023 18:15:57 +0800 Subject: [PATCH 06/16] feat(exporter-logs-otlp-grpc): adds package --- .../exporter-logs-otlp-grpc/.eslintignore | 1 + .../exporter-logs-otlp-grpc/.eslintrc.js | 8 + .../exporter-logs-otlp-grpc/.npmignore | 4 + .../packages/exporter-logs-otlp-grpc/LICENSE | 201 ++++++++++ .../exporter-logs-otlp-grpc/README.md | 101 +++++ .../exporter-logs-otlp-grpc/package.json | 82 +++++ .../src/OTLPLogsExporter.ts | 77 ++++ .../exporter-logs-otlp-grpc/src/index.ts | 17 + .../test/OTLPLogsExporter.test.ts | 346 ++++++++++++++++++ .../exporter-logs-otlp-grpc/test/certs/ca.crt | 33 ++ .../exporter-logs-otlp-grpc/test/certs/ca.key | 51 +++ .../test/certs/client.crt | 31 ++ .../test/certs/client.csr | 28 ++ .../test/certs/client.key | 51 +++ .../test/certs/regenerate.sh | 22 ++ .../test/certs/server.crt | 31 ++ .../test/certs/server.csr | 28 ++ .../test/certs/server.key | 51 +++ .../test/logsHelper.ts | 173 +++++++++ .../exporter-logs-otlp-grpc/tsconfig.json | 37 ++ .../src/utils/environment.ts | 18 + tsconfig.json | 4 + 22 files changed, 1395 insertions(+) create mode 100644 experimental/packages/exporter-logs-otlp-grpc/.eslintignore create mode 100644 experimental/packages/exporter-logs-otlp-grpc/.eslintrc.js create mode 100644 experimental/packages/exporter-logs-otlp-grpc/.npmignore create mode 100644 experimental/packages/exporter-logs-otlp-grpc/LICENSE create mode 100644 experimental/packages/exporter-logs-otlp-grpc/README.md create mode 100644 experimental/packages/exporter-logs-otlp-grpc/package.json create mode 100644 experimental/packages/exporter-logs-otlp-grpc/src/OTLPLogsExporter.ts create mode 100644 experimental/packages/exporter-logs-otlp-grpc/src/index.ts create mode 100644 experimental/packages/exporter-logs-otlp-grpc/test/OTLPLogsExporter.test.ts create mode 100644 experimental/packages/exporter-logs-otlp-grpc/test/certs/ca.crt create mode 100644 experimental/packages/exporter-logs-otlp-grpc/test/certs/ca.key create mode 100644 experimental/packages/exporter-logs-otlp-grpc/test/certs/client.crt create mode 100644 experimental/packages/exporter-logs-otlp-grpc/test/certs/client.csr create mode 100644 experimental/packages/exporter-logs-otlp-grpc/test/certs/client.key create mode 100755 experimental/packages/exporter-logs-otlp-grpc/test/certs/regenerate.sh create mode 100644 experimental/packages/exporter-logs-otlp-grpc/test/certs/server.crt create mode 100644 experimental/packages/exporter-logs-otlp-grpc/test/certs/server.csr create mode 100644 experimental/packages/exporter-logs-otlp-grpc/test/certs/server.key create mode 100644 experimental/packages/exporter-logs-otlp-grpc/test/logsHelper.ts create mode 100644 experimental/packages/exporter-logs-otlp-grpc/tsconfig.json diff --git a/experimental/packages/exporter-logs-otlp-grpc/.eslintignore b/experimental/packages/exporter-logs-otlp-grpc/.eslintignore new file mode 100644 index 0000000000..378eac25d3 --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/.eslintignore @@ -0,0 +1 @@ +build diff --git a/experimental/packages/exporter-logs-otlp-grpc/.eslintrc.js b/experimental/packages/exporter-logs-otlp-grpc/.eslintrc.js new file mode 100644 index 0000000000..3ed0fbeba3 --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/.eslintrc.js @@ -0,0 +1,8 @@ +module.exports = { + "env": { + "mocha": true, + "commonjs": true, + "node": true, + }, + ...require('../../../eslint.config.js') +} diff --git a/experimental/packages/exporter-logs-otlp-grpc/.npmignore b/experimental/packages/exporter-logs-otlp-grpc/.npmignore new file mode 100644 index 0000000000..9505ba9450 --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/.npmignore @@ -0,0 +1,4 @@ +/bin +/coverage +/doc +/test diff --git a/experimental/packages/exporter-logs-otlp-grpc/LICENSE b/experimental/packages/exporter-logs-otlp-grpc/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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 + + http://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. diff --git a/experimental/packages/exporter-logs-otlp-grpc/README.md b/experimental/packages/exporter-logs-otlp-grpc/README.md new file mode 100644 index 0000000000..fdfed3d38c --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/README.md @@ -0,0 +1,101 @@ +# OpenTelemetry Collector Logs Exporter for node with grpc + +[![NPM Published Version][npm-img]][npm-url] +[![Apache License][license-image]][license-image] + +**Note: This is an experimental package under active development. New releases may include breaking changes.** + +This module provides exporter for node to be used with OTLP (`grpc`) compatible receivers. +Compatible with [opentelemetry-collector][opentelemetry-collector-url] versions `>=0.16 <=0.53`. + +## Installation + +```bash +npm install --save @opentelemetry/exporter-logs-otlp-grpc +``` + +## Service Name + +The OpenTelemetry Collector Exporter does not have a service name configuration. +In order to set the service name, use the `service.name` resource attribute as prescribed in the [OpenTelemetry Resource Semantic Conventions][semconv-resource-service-name]. +To see documentation and sample code for the traces exporter, as well as instructions for using TLS, visit the [Collector Trace Exporter for web and node][trace-exporter-url]. +To see documentation and sample code for the metric exporter, see the [exporter-metrics-otlp-grpc package][metrics-exporter-url] + +## Logs in Node - GRPC + +The OTLPLogsExporter in Node expects the URL to only be the hostname. It will not work with `/v1/logs`. All +options that work with trace also work with logs. + +```js +import { + LoggerProvider, + SimpleLogRecordProcessor, +} from '@opentelemetry/sdk-logs'; +import { OTLPLogsExporter } from '@opentelemetry/exporter-logs-otlp-grpc'; + +const collectorOptions = { + // url is optional and can be omitted - default is http://localhost:4317 + url: 'http://:', +}; + +const loggerExpoter = new OTLPLogsExporter(collectorOptions); +const loggerProvider = new LoggerProvider(); + +loggerProvider.addLogRecordProcessor( + new SimpleLogRecordProcessor(loggerExpoter) +); + +['SIGINT', 'SIGTERM'].forEach(signal => { + process.on(signal, () => loggerProvider.shutdown().catch(console.error)); +}); + +// logging +const logger = loggerProvider.getLogger('example-logger'); +logger.emit({ body: 'example-log' }); +``` + +## Environment Variable Configuration + +| Environment variable | Description | +|----------------------|-------------| +| OTEL_EXPORTER_OTLP_LOGS_ENDPOINT | The endpoint to send logs to. By default `localhost:4317` will be used. | +| OTEL_EXPORTER_OTLP_ENDPOINT | The endpoint to send trace, metric, and logs to. By default `localhost:4317` will be used. | +| OTEL_EXPORTER_OTLP_LOGS_COMPRESSION | The compression type to use on OTLP logs requests. Options include gzip. By default no compression will be used. | +| OTEL_EXPORTER_OTLP_COMPRESSION | The compression type to use on OTLP trace, metric, and log requests. Options include gzip. By default no compression will be used. | +| OTEL_EXPORTER_OTLP_LOGS_INSECURE | Whether to enable client transport security for the exporter's gRPC connection for logs requests. This option only applies to OTLP/gRPC when an endpoint is provided without the http or https scheme. Options include true or false. By default insecure is false which creates a secure connection. | +| OTEL_EXPORTER_OTLP_INSECURE | Whether to enable client transport security for the exporter's gRPC connection for trace, metric and log requests. This option only applies to OTLP/gRPC when an endpoint is provided without the http or https scheme. Options include true or false. By default insecure is false which creates a secure connection. | +| OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE | The path to the file containing trusted root certificate to use when verifying an OTLP logs server's TLS credentials. By default the host platform's trusted root certificate is used.| +| OTEL_EXPORTER_OTLP_CERTIFICATE | The path to the file containing trusted root certificate to use when verifying an OTLP trace, metric, or log server's TLS credentials. By default the host platform's trusted root certificate is used. | +| OTEL_EXPORTER_OTLP_LOGS_CLIENT_KEY | The path to the file containing private client key to use when verifying an OTLP logs client's TLS credentials. Must provide a client certificate/chain when providing a private client key. By default no client key file is used. | +| OTEL_EXPORTER_OTLP_CLIENT_KEY | The path to the file containing private client key to use when verifying an OTLP trace, metric or log client's TLS credentials. Must provide a client certificate/chain when providing a private client key. By default no client key file is used. | +| OTEL_EXPORTER_OTLP_LOGS_CLIENT_CERTIFICATE | The path to the file containing trusted client certificate/chain for clients private key to use when verifying an OTLP logs server's TLS credentials. Must provide a private client key when providing a certificate/chain. By default no chain file is used. | +| OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE | The path to the file containing trusted client certificate/chain for clients private key to use when verifying an OTLP trace, metric and log server's TLS credentials. Must provide a private client key when providing a certificate/chain. By default no chain file is used. | +| OTEL_EXPORTER_OTLP_LOGS_TIMEOUT | The maximum waiting time, in milliseconds, allowed to send each OTLP logs batch. Default is 10000. | +| OTEL_EXPORTER_OTLP_TIMEOUT | The maximum waiting time, in milliseconds, allowed to send each OTLP trace and metric batch. Default is 10000. | + +> Settings configured programmatically take precedence over environment variables. Per-signal environment variables take precedence over non-per-signal environment variables. + +## Running opentelemetry-collector locally to see the logs + +1. Go to `examples/otlp-exporter-node` +2. Follow the instructions there to view logs. + +## Useful links + +- For more information on OpenTelemetry, visit: +- For more about OpenTelemetry JavaScript: +- For help or feedback on this project, join us in [GitHub Discussions][discussions-url] + +## License + +Apache 2.0 - See [LICENSE][license-url] for more information. + +[discussions-url]: https://github.com/open-telemetry/opentelemetry-js/discussions +[license-url]: https://github.com/open-telemetry/opentelemetry-js/blob/main/LICENSE +[license-image]: https://img.shields.io/badge/license-Apache_2.0-green.svg?style=flat +[npm-url]: https://www.npmjs.com/package/@opentelemetry/exporter-logs-otlp-grpc +[npm-img]: https://badge.fury.io/js/%40opentelemetry%2Fexporter-logs-otlp-grpc.svg +[opentelemetry-collector-url]: https://github.com/open-telemetry/opentelemetry-collector +[semconv-resource-service-name]: https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/resource/semantic_conventions/README.md#service +[trace-exporter-url]: https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/exporter-trace-otlp-grpc +[metrics-exporter-url]: https://github.com/open-telemetry/opentelemetry-js/tree/main/experimental/packages/opentelemetry-exporter-metrics-otlp-grpc diff --git a/experimental/packages/exporter-logs-otlp-grpc/package.json b/experimental/packages/exporter-logs-otlp-grpc/package.json new file mode 100644 index 0000000000..313a19b7e3 --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/package.json @@ -0,0 +1,82 @@ +{ + "name": "@opentelemetry/exporter-logs-otlp-grpc", + "version": "0.38.0", + "description": "OpenTelemetry Collector Exporter allows user to send collected log records to the OpenTelemetry Collector", + "main": "build/src/index.js", + "types": "build/src/index.d.ts", + "repository": "open-telemetry/opentelemetry-js", + "scripts": { + "prepublishOnly": "npm run compile", + "compile": "tsc --build", + "clean": "tsc --build --clean", + "lint": "eslint . --ext .ts", + "lint:fix": "eslint . --ext .ts --fix", + "tdd": "npm run test -- --watch-extensions ts --watch", + "test": "nyc ts-mocha -p tsconfig.json 'test/**/*.test.ts'", + "version": "node ../../../scripts/version-update.js", + "watch": "tsc --watch --build", + "precompile": "lerna run version --scope $(npm pkg get name) --include-dependencies", + "prewatch": "npm run precompile", + "peer-api-check": "node ../../../scripts/peer-api-check.js", + "codecov": "nyc report --reporter=json && codecov -f coverage/*.json -p ../../../" + }, + "keywords": [ + "opentelemetry", + "nodejs", + "grpc", + "tracing", + "profiling", + "metrics", + "stats", + "logging" + ], + "author": "OpenTelemetry Authors", + "license": "Apache-2.0", + "engines": { + "node": ">=14" + }, + "files": [ + "build/src/**/*.js", + "build/src/**/*.js.map", + "build/src/**/*.d.ts", + "build/protos/**/*.proto", + "doc", + "LICENSE", + "README.md" + ], + "publishConfig": { + "access": "public" + }, + "devDependencies": { + "@babel/core": "7.16.0", + "@grpc/proto-loader": "^0.7.3", + "@opentelemetry/api": "1.4.1", + "@opentelemetry/api-logs": "0.38.0", + "@opentelemetry/otlp-exporter-base": "0.38.0", + "@opentelemetry/resources": "1.12.0", + "@opentelemetry/sdk-logs": "0.38.0", + "@types/mocha": "10.0.0", + "@types/node": "18.6.5", + "@types/sinon": "10.0.13", + "codecov": "3.8.3", + "cpx": "1.5.0", + "mocha": "10.0.0", + "nyc": "15.1.0", + "rimraf": "4.1.2", + "sinon": "15.0.0", + "ts-loader": "8.4.0", + "ts-mocha": "10.0.0", + "typescript": "4.4.4" + }, + "peerDependencies": { + "@opentelemetry/api": "^1.0.0" + }, + "dependencies": { + "@grpc/grpc-js": "^1.7.1", + "@opentelemetry/core": "1.12.0", + "@opentelemetry/otlp-grpc-exporter-base": "0.38.0", + "@opentelemetry/otlp-transformer": "0.38.0" + }, + "homepage": "https://github.com/open-telemetry/opentelemetry-js/tree/main/experimental/packages/exporter-logs-otlp-grpc", + "sideEffects": false +} \ No newline at end of file diff --git a/experimental/packages/exporter-logs-otlp-grpc/src/OTLPLogsExporter.ts b/experimental/packages/exporter-logs-otlp-grpc/src/OTLPLogsExporter.ts new file mode 100644 index 0000000000..e4484fdb39 --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/src/OTLPLogsExporter.ts @@ -0,0 +1,77 @@ +/* + * 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 { LogRecordExporter, ReadableLogRecord } from '@opentelemetry/sdk-logs'; +import { baggageUtils, getEnv } from '@opentelemetry/core'; +import { Metadata } from '@grpc/grpc-js'; +import { + OTLPGRPCExporterConfigNode, + OTLPGRPCExporterNodeBase, + ServiceClientType, + validateAndNormalizeUrl, + DEFAULT_COLLECTOR_URL, +} from '@opentelemetry/otlp-grpc-exporter-base'; +import { + createExportLogsServiceRequest, + IExportLogsServiceRequest, +} from '@opentelemetry/otlp-transformer'; + +/** + * OTLP Logs Exporter for Node + */ +export class OTLPLogsExporter + extends OTLPGRPCExporterNodeBase + implements LogRecordExporter +{ + constructor(config: OTLPGRPCExporterConfigNode = {}) { + super(config); + const headers = baggageUtils.parseKeyPairsIntoRecord( + getEnv().OTEL_EXPORTER_OTLP_LOGS_HEADERS + ); + this.metadata ||= new Metadata(); + for (const [k, v] of Object.entries(headers)) { + this.metadata.set(k, v); + } + } + + convert(logRecords: ReadableLogRecord[]): IExportLogsServiceRequest { + return createExportLogsServiceRequest(logRecords); + } + + getDefaultUrl(config: OTLPGRPCExporterConfigNode) { + return validateAndNormalizeUrl(this.getUrlFromConfig(config)); + } + + getServiceClientType() { + return ServiceClientType.LOGS; + } + + getServiceProtoPath(): string { + return 'opentelemetry/proto/collector/logs/v1/logs_service.proto'; + } + + getUrlFromConfig(config: OTLPGRPCExporterConfigNode): string { + if (typeof config.url === 'string') { + return config.url; + } + + return ( + getEnv().OTEL_EXPORTER_OTLP_LOGS_ENDPOINT || + getEnv().OTEL_EXPORTER_OTLP_ENDPOINT || + DEFAULT_COLLECTOR_URL + ); + } +} diff --git a/experimental/packages/exporter-logs-otlp-grpc/src/index.ts b/experimental/packages/exporter-logs-otlp-grpc/src/index.ts new file mode 100644 index 0000000000..b35d852d90 --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/src/index.ts @@ -0,0 +1,17 @@ +/* + * 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. + */ + +export * from './OTLPLogsExporter'; diff --git a/experimental/packages/exporter-logs-otlp-grpc/test/OTLPLogsExporter.test.ts b/experimental/packages/exporter-logs-otlp-grpc/test/OTLPLogsExporter.test.ts new file mode 100644 index 0000000000..d413b8902d --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/test/OTLPLogsExporter.test.ts @@ -0,0 +1,346 @@ +/* + * 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 protoLoader from '@grpc/proto-loader'; +import { diag } from '@opentelemetry/api'; + +import * as assert from 'assert'; +import * as fs from 'fs'; +import * as grpc from '@grpc/grpc-js'; +import * as path from 'path'; +import * as sinon from 'sinon'; +import { OTLPLogsExporter } from '../src'; + +import { + ensureExportedLogRecordIsCorrect, + ensureMetadataIsCorrect, + ensureResourceIsCorrect, + mockedReadableLogRecord, +} from './logsHelper'; +import * as core from '@opentelemetry/core'; +import { CompressionAlgorithm } from '@opentelemetry/otlp-exporter-base'; +import { GrpcCompressionAlgorithm } from '@opentelemetry/otlp-grpc-exporter-base'; +import { + IExportLogsServiceRequest, + IResourceLogs, +} from '@opentelemetry/otlp-transformer'; + +const logsServiceProtoPath = + 'opentelemetry/proto/collector/logs/v1/logs_service.proto'; +const includeDirs = [ + path.resolve(__dirname, '../../otlp-grpc-exporter-base/protos'), +]; + +const address = 'localhost:1501'; + +type TestParams = { + useTLS?: boolean; + metadata?: grpc.Metadata; +}; + +const metadata = new grpc.Metadata(); +metadata.set('k', 'v'); + +const testCollectorExporter = (params: TestParams) => + describe(`OTLPLogsExporter - node ${ + params.useTLS ? 'with' : 'without' + } TLS, ${params.metadata ? 'with' : 'without'} metadata`, () => { + let collectorExporter: OTLPLogsExporter; + let server: grpc.Server; + let exportedData: IResourceLogs | undefined; + let reqMetadata: grpc.Metadata | undefined; + + before(done => { + server = new grpc.Server(); + protoLoader + .load(logsServiceProtoPath, { + keepCase: false, + longs: String, + enums: String, + defaults: true, + oneofs: true, + includeDirs, + }) + .then((packageDefinition: protoLoader.PackageDefinition) => { + const packageObject: any = + grpc.loadPackageDefinition(packageDefinition); + server.addService( + packageObject.opentelemetry.proto.collector.logs.v1.LogsService + .service, + { + Export: (data: { + request: IExportLogsServiceRequest; + metadata: grpc.Metadata; + }) => { + if (data.request.resourceLogs != null) { + exportedData = data.request.resourceLogs[0]; + } + reqMetadata = data.metadata; + }, + } + ); + const credentials = params.useTLS + ? grpc.ServerCredentials.createSsl( + fs.readFileSync('./test/certs/ca.crt'), + [ + { + cert_chain: fs.readFileSync('./test/certs/server.crt'), + private_key: fs.readFileSync('./test/certs/server.key'), + }, + ] + ) + : grpc.ServerCredentials.createInsecure(); + server.bindAsync(address, credentials, () => { + server.start(); + done(); + }); + }); + }); + + after(() => { + server.forceShutdown(); + }); + + beforeEach(done => { + const credentials = params.useTLS + ? grpc.credentials.createSsl( + fs.readFileSync('./test/certs/ca.crt'), + fs.readFileSync('./test/certs/client.key'), + fs.readFileSync('./test/certs/client.crt') + ) + : grpc.credentials.createInsecure(); + collectorExporter = new OTLPLogsExporter({ + url: 'https://' + address, + credentials, + metadata: params.metadata, + }); + done(); + }); + + afterEach(() => { + exportedData = undefined; + reqMetadata = undefined; + sinon.restore(); + }); + + describe('instance', () => { + it('should warn about headers when using grpc', () => { + // Need to stub/spy on the underlying logger as the 'diag' instance is global + const spyLoggerWarn = sinon.stub(diag, 'warn'); + collectorExporter = new OTLPLogsExporter({ + url: `http://${address}`, + headers: { + foo: 'bar', + }, + }); + const args = spyLoggerWarn.args[0]; + assert.strictEqual(args[0], 'Headers cannot be set when using grpc'); + }); + it('should warn about path in url', () => { + const spyLoggerWarn = sinon.stub(diag, 'warn'); + collectorExporter = new OTLPLogsExporter({ + url: `http://${address}/v1/logs`, + }); + const args = spyLoggerWarn.args[0]; + assert.strictEqual( + args[0], + 'URL path should not be set when using grpc, the path part of the URL will be ignored.' + ); + }); + }); + + describe('export', () => { + it('should export log records', done => { + const responseSpy = sinon.spy(); + const logRecords = [Object.assign({}, mockedReadableLogRecord)]; + collectorExporter.export(logRecords, responseSpy); + setTimeout(() => { + assert.ok( + typeof exportedData !== 'undefined', + 'resource' + " doesn't exist" + ); + + const logs = exportedData.scopeLogs[0].logRecords; + const resource = exportedData.resource; + + assert.ok(typeof logs !== 'undefined', 'log records do not exist'); + + ensureExportedLogRecordIsCorrect(logs[0]); + + assert.ok(typeof resource !== 'undefined', "resource doesn't exist"); + + ensureResourceIsCorrect(resource); + + ensureMetadataIsCorrect(reqMetadata, params?.metadata); + + done(); + }, 500); + }); + it('should log deadline exceeded error', done => { + const credentials = params.useTLS + ? grpc.credentials.createSsl( + fs.readFileSync('./test/certs/ca.crt'), + fs.readFileSync('./test/certs/client.key'), + fs.readFileSync('./test/certs/client.crt') + ) + : grpc.credentials.createInsecure(); + + const collectorExporterWithTimeout = new OTLPLogsExporter({ + url: 'grpcs://' + address, + credentials, + metadata: params.metadata, + timeoutMillis: 100, + }); + + const responseSpy = sinon.spy(); + const logRecords = [Object.assign({}, mockedReadableLogRecord)]; + collectorExporterWithTimeout.export(logRecords, responseSpy); + + setTimeout(() => { + const result = responseSpy.args[0][0] as core.ExportResult; + assert.strictEqual(result.code, core.ExportResultCode.FAILED); + assert.strictEqual( + responseSpy.args[0][0].error.details, + 'Deadline exceeded' + ); + done(); + }, 300); + }); + }); + describe('export - with gzip compression', () => { + beforeEach(() => { + const credentials = params.useTLS + ? grpc.credentials.createSsl( + fs.readFileSync('./test/certs/ca.crt'), + fs.readFileSync('./test/certs/client.key'), + fs.readFileSync('./test/certs/client.crt') + ) + : grpc.credentials.createInsecure(); + collectorExporter = new OTLPLogsExporter({ + url: 'https://' + address, + credentials, + metadata: params.metadata, + compression: CompressionAlgorithm.GZIP, + }); + }); + it('should successfully send the spans', done => { + const responseSpy = sinon.spy(); + const logRecords = [Object.assign({}, mockedReadableLogRecord)]; + collectorExporter.export(logRecords, responseSpy); + setTimeout(() => { + assert.ok( + typeof exportedData !== 'undefined', + 'resource' + " doesn't exist" + ); + const logs = exportedData.scopeLogs[0].logRecords; + const resource = exportedData.resource; + + assert.ok(typeof logs !== 'undefined', 'spans do not exist'); + ensureExportedLogRecordIsCorrect(logs[0]); + + assert.ok(typeof resource !== 'undefined', "resource doesn't exist"); + ensureResourceIsCorrect(resource); + + ensureMetadataIsCorrect(reqMetadata, params.metadata); + + done(); + }, 500); + }); + }); + describe('Logs Exporter with compression', () => { + const envSource = process.env; + it('should return gzip compression algorithm on exporter', () => { + const credentials = params.useTLS + ? grpc.credentials.createSsl( + fs.readFileSync('./test/certs/ca.crt'), + fs.readFileSync('./test/certs/client.key'), + fs.readFileSync('./test/certs/client.crt') + ) + : grpc.credentials.createInsecure(); + + envSource.OTEL_EXPORTER_OTLP_COMPRESSION = 'gzip'; + collectorExporter = new OTLPLogsExporter({ + url: 'https://' + address, + credentials, + metadata: params.metadata, + }); + assert.strictEqual( + collectorExporter.compression, + GrpcCompressionAlgorithm.GZIP + ); + delete envSource.OTEL_EXPORTER_OTLP_COMPRESSION; + }); + }); + }); + +describe('OTLPLogsExporter - node (getDefaultUrl)', () => { + it('should default to localhost', done => { + const collectorExporter = new OTLPLogsExporter({}); + setTimeout(() => { + assert.strictEqual(collectorExporter['url'], 'localhost:4317'); + done(); + }); + }); + it('should keep the URL if included', done => { + const url = 'http://foo.bar.com'; + const collectorExporter = new OTLPLogsExporter({ url }); + setTimeout(() => { + assert.strictEqual(collectorExporter['url'], 'foo.bar.com'); + done(); + }); + }); +}); + +describe('when configuring via environment', () => { + const envSource = process.env; + it('should use url defined in env', () => { + envSource.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://foo.bar'; + const collectorExporter = new OTLPLogsExporter(); + assert.strictEqual(collectorExporter.url, 'foo.bar'); + envSource.OTEL_EXPORTER_OTLP_ENDPOINT = ''; + }); + it('should override global exporter url with signal url defined in env', () => { + envSource.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://foo.bar'; + envSource.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT = 'http://foo.logs'; + const collectorExporter = new OTLPLogsExporter(); + assert.strictEqual(collectorExporter.url, 'foo.logs'); + envSource.OTEL_EXPORTER_OTLP_ENDPOINT = ''; + envSource.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT = ''; + }); + it('should use headers defined via env', () => { + envSource.OTEL_EXPORTER_OTLP_HEADERS = 'foo=bar'; + const collectorExporter = new OTLPLogsExporter(); + assert.deepStrictEqual(collectorExporter.metadata?.get('foo'), ['bar']); + envSource.OTEL_EXPORTER_OTLP_HEADERS = ''; + }); + it('should override global headers config with signal headers defined via env', () => { + const metadata = new grpc.Metadata(); + metadata.set('foo', 'bar'); + metadata.set('goo', 'lol'); + envSource.OTEL_EXPORTER_OTLP_HEADERS = 'foo=jar,bar=foo'; + envSource.OTEL_EXPORTER_OTLP_LOGS_HEADERS = 'foo=boo'; + const collectorExporter = new OTLPLogsExporter({ metadata }); + assert.deepStrictEqual(collectorExporter.metadata?.get('foo'), ['boo']); + assert.deepStrictEqual(collectorExporter.metadata?.get('bar'), ['foo']); + assert.deepStrictEqual(collectorExporter.metadata?.get('goo'), ['lol']); + envSource.OTEL_EXPORTER_OTLP_LOGS_HEADERS = ''; + envSource.OTEL_EXPORTER_OTLP_HEADERS = ''; + }); +}); + +testCollectorExporter({ useTLS: true }); +testCollectorExporter({ useTLS: false }); +testCollectorExporter({ metadata }); diff --git a/experimental/packages/exporter-logs-otlp-grpc/test/certs/ca.crt b/experimental/packages/exporter-logs-otlp-grpc/test/certs/ca.crt new file mode 100644 index 0000000000..27e1d6826b --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/test/certs/ca.crt @@ -0,0 +1,33 @@ +-----BEGIN CERTIFICATE----- +MIIFozCCA4ugAwIBAgIUC57UkrmvltHwm0jdwHjbFx/wIcMwDQYJKoZIhvcNAQEL +BQAwYTELMAkGA1UEBhMCQ0wxCzAJBgNVBAgMAlJNMRowGAYDVQQHDBFPcGVuVGVs +ZW1ldHJ5VGVzdDENMAsGA1UECgwEUm9vdDENMAsGA1UECwwEVGVzdDELMAkGA1UE +AwwCY2EwHhcNMjIwNjA4MDk1MzU5WhcNMjMwNjA4MDk1MzU5WjBhMQswCQYDVQQG +EwJDTDELMAkGA1UECAwCUk0xGjAYBgNVBAcMEU9wZW5UZWxlbWV0cnlUZXN0MQ0w +CwYDVQQKDARSb290MQ0wCwYDVQQLDARUZXN0MQswCQYDVQQDDAJjYTCCAiIwDQYJ +KoZIhvcNAQEBBQADggIPADCCAgoCggIBANu7HBCDdS5EStAQP7W4K17xcEzGWB9w ++m8/pZpMIQMVJ0AvvxkGC1rp/uYzcFKjymCqOqFRjTVza5s3ltk6DEJKbwkszAIi +UTA26/AIKxy9iWCqbqS34utSIA8SfUDJx+Nb9PHW2/BZ9DqLsNqxUeq/3NO59z3/ +uMQt3rM7ijO8ETuWkXmje5r9WiuMXIapVBSzKaKwIuX8ikZnXWHFlP9Hej7UMNAl +qx5w/WVO/18UIqJRtwG7+uEN1uut+Jw1fqswctE+69yg1/TgrF9A9kx9e81ZKR9L +JE3K/BZw5z3jRVNxfyhWVCPS8G3znmijuToaS7GpL6S3Nxp7vYxjPx3F6K5DzF2t +Yz1qz6iyxvhm3J/TLz6OzJqP7qIg0Di1HBc/PdzGVSb35VxPYFwWjrAGWL3EzmWz +6ArQDCQdK6tSKlL2LpN0IHxOCSImQDZMB9YpveNenVBuLFhNGZAiow38WlXBS0RC +yQDBjhzwZJO5YE+itycxwFaLvyF/hLjfh5d7C+0tjoLRDZ3OlZQCHO+zdN/ZgZI9 +gx9NRyqmNudPhVzjN8+kQf7iXY0J+aT2XzPZzvMm2vKEB2BalP7iQ1aN+Szz1S5n +ESFDQgEnu9JjjZ/hcUuXNpi03m7O/pMq++fJ7Pib9YG93cBNYSRFulWU1rTD8z+Y +BE8Z+cluZD9xAgMBAAGjUzBRMB0GA1UdDgQWBBRZTBtOna2cDAuO5UP1Je85TKsE +CTAfBgNVHSMEGDAWgBRZTBtOna2cDAuO5UP1Je85TKsECTAPBgNVHRMBAf8EBTAD +AQH/MA0GCSqGSIb3DQEBCwUAA4ICAQBWDujXcuCir18SZhm7ipTwRz50KG7x1W5/ +p32hHJlEYh83+7vytsVwO8W6Ugn8R76mIIeevZv5ahxZeNdLNKrF6qjwZp/INY64 +pO2rUiDqkbU8csQZm5mUMmEa06WytAims5e3wNzLlBEKCUArAy6jMctXm054uQiv +VPk79CEonOjvZBh72QAV+wDCm8oq7TGPgmLPYQkdg3ncPjAu1ubPoPupsUZKmO9G +369t/n5JNDM03Ksek3WFRr88xNIeGRwfAPkJH+XKuikM5PawKfkIX1S//C+NKwdG +9I5d+gO40Ap9itUGr4m0E541isW/poFzcEw8P+UV7WvPNJyCvdOxEIvji4SbLl4h +oCS2qNeREuhtfX0jGzxc9pfrj1w14159tpnwQay2Sf6UOSr6OSl46lETAQaWzJz+ +r/FDHy+T7THqvp++JlIkCfvtMZRXdCX6eRghc/03qSpizhDsAB3hMy/Yq3FA95WT +Rx56YJgzvEH1BUxfc/peTr6BGNEaonRvf9i2dnf+Z3jCJAn4WeKfTDmcpSnmcK4s +dOhQOYnupZCu8mYyC5aOPFB/Ovtm5USJDlWujUm+EjIaOUiPDqP7ff2wQX9+ympF +7xjbanad5F3E1gl623VuhGTI6jUiY5TnxVwh67WxIMb2/bP5Ko27/JmWbbJ1/Dar +g2LKPYSY8A== +-----END CERTIFICATE----- diff --git a/experimental/packages/exporter-logs-otlp-grpc/test/certs/ca.key b/experimental/packages/exporter-logs-otlp-grpc/test/certs/ca.key new file mode 100644 index 0000000000..3ca1e8e149 --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/test/certs/ca.key @@ -0,0 +1,51 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIJKQIBAAKCAgEA27scEIN1LkRK0BA/tbgrXvFwTMZYH3D6bz+lmkwhAxUnQC+/ +GQYLWun+5jNwUqPKYKo6oVGNNXNrmzeW2ToMQkpvCSzMAiJRMDbr8AgrHL2JYKpu +pLfi61IgDxJ9QMnH41v08dbb8Fn0Oouw2rFR6r/c07n3Pf+4xC3eszuKM7wRO5aR +eaN7mv1aK4xchqlUFLMporAi5fyKRmddYcWU/0d6PtQw0CWrHnD9ZU7/XxQiolG3 +Abv64Q3W6634nDV+qzBy0T7r3KDX9OCsX0D2TH17zVkpH0skTcr8FnDnPeNFU3F/ +KFZUI9LwbfOeaKO5OhpLsakvpLc3Gnu9jGM/HcXorkPMXa1jPWrPqLLG+Gbcn9Mv +Po7Mmo/uoiDQOLUcFz893MZVJvflXE9gXBaOsAZYvcTOZbPoCtAMJB0rq1IqUvYu +k3QgfE4JIiZANkwH1im9416dUG4sWE0ZkCKjDfxaVcFLRELJAMGOHPBkk7lgT6K3 +JzHAVou/IX+EuN+Hl3sL7S2OgtENnc6VlAIc77N039mBkj2DH01HKqY250+FXOM3 +z6RB/uJdjQn5pPZfM9nO8yba8oQHYFqU/uJDVo35LPPVLmcRIUNCASe70mONn+Fx +S5c2mLTebs7+kyr758ns+Jv1gb3dwE1hJEW6VZTWtMPzP5gETxn5yW5kP3ECAwEA +AQKCAgEAnktsi2T4zSz7rGqYSyRzckGDQnv9TiFI+U4j0kWX3q2lijMbez6Efaln +LZXPDGncyMi51i93CBOvaLGiZbnQzQzscvKnwb3ROWfHjzODQ4Az8MS3Usj6m8ad +O955B2yWKO+9RWAhMETNkkPCU7o8pl40Cv/E4xBPnlzhO8Pf6ydITuJIyRWCXYS5 +KfhDS+u+m+76Rq6XZZIKV2/tsRrzHPj0U0DwLXOFlDeYBRzlEiziSoeNzJ0MvocG +1uCM4pQTPeZ4QNAQgPAKw+n7o9+b0DzyLFxYKKgsbjKWauBJZqdM8TEphviyQuCa +vssrynxwWzBIaaPVo9ctxlFwmyuAcm+ma6Imz6yEWWKw11ZkC+Vf+IBusuuSUjE7 +hnvaJNTZOPByHYJQhbYrmVpjt8toPweQrlKGalTTbV3t0p73KffwoFRVO3ZinprI +8vjPaNs4+kM22kLXjDKMv+fdWToJVzvoqaCDqVsabbbNg0Y4QxwfGReHmB0lRaWU ++qZv6c5yubfgpZjW4E9pkSUY5LR9qJeNlKK3IFbpwqKPN2NtxPfRtmCfMdM9K/BJ +loqm2HvP+kbQK+wE436BBtAvn2AX6DM5sPBCltRWhzyFrmPjcBjngCBPVcCzCpqZ ++mpQkv/6dtANFl6kbx7I6ovUB0i6Ol+L+vAY6IclUU/gSGsT6gECggEBAPMFg2Jc +NjhdOREE6oKLI7w0Nto1Rz/exSDGG8b4vp3v3YWVUw8jqgi96XUI43grcJUPvHhh +ttUanlF1pam2LDt+dz53hUxfgXqcChXiny+pqW+OJ4t7ibKuNlv3smBOLrSPIkEw +84xJmG/87CCaT6n3hYx2wJKOvBAfzFrlRiQ80+RsLwy84zYW4TpsGWERlbpdvaj3 +lONN4Z9i/5ucMxQeWAAdHpNEIiBN5EQ/G8sYTdNCWfqLMxxD672d9TH1olFJdKeO +KHMdB++JGNsRigD8xeB0qQlyb4Mj1rgGi1nst7IKoNiUruOcbnlqsoL10khkfRIe +aEiI/dq+zSuZhdECggEBAOd3LT3aLnSYU2EuZeWa++ZO/4CiXjA3WCD3PPxt8LOz +mSGaMOLehxYW6HHqGorQLZwcj0MrktuVO20/HJSwBj+AwWX4yOTLUIs3GcdWO+64 +DnWW0ZMxqGZei6wUKIj6O44AXQBQvpAvcmAoO2cbAxKXT59RCGVJoWhrOqRwKjqb +0fLX6Lebz/hYoc+d24cbmfhzGVxQY5J38p4WFeQmInlG+8PefHUeYOae1ZX6dTNo +ZYk3nJUoKZ6OywVO4WRlaJGs1Deh0tJYNOCMjdOOF7aTH5J5SVHiWw8e+zTjicd5 +yOOb4k7mGRoTHW8ukFwccHaGtgK4nWwiNhdlO94AZ6ECggEAVKonC610dk6EAxnj +WXeAC6FlOsA1Altp8fES3E7smblnQ5KyTSPvqPwAyXU/Si5YGpZQ4t+oArYzUc3a +2TVOU6vLf0fEeMcNJNoX6Wf6bXB+Rw8PV9jCMC3hYkj5K/QQ8XasSGn1b3p0UQ+c +c/9OobhKHpWAoY54lmV9nG0j8pv+diX6fkWQItf1v5TJgrfNog/mc2dNx6LqZ8zl +oCDa6rdnkSKT9FpYSUjZra0O0cK12lPTZSX5uG8xQe417iHVWtxsd7NfBDuo+Bqb +PjbuDUoC5h++hDwJ/XYO6C3ffoSpuq1ZPBsQktt84W/6oQVjLTVVHWraieqwBfVT +JU1nAQKCAQEA31FOZwSgGYH1wCdBzHrxWk0RmgwNj7t13ahsQKfZuacnsRHQ5LIJ +5zgG4BEbtp4PwzSSzB24PP8ILOjdLF+AR7hz32xeds/qT8bDqlz6yeDuomj2nmsk +rE+/tjBkw3OaDfEvyWQd14LPeRKX7WxUVJWEDpPh48dcYSBDne9R7uXzc7b4Il3E +EzmANI17BimNLfXum/A7gU8U1407ZbmdPSFNOrbnoR/EIf1Q2LiiZwzsGa179zSe +ownluqNWNsTYVORIg7wvaR4NNjCljVzkaBQeO/Wk1cnsTPR5LZfykHBhb6gweirq +QQv8NA7a3OPbZZ+m740q5O9E/OGBFzmQwQKCAQBsSZ+9RNUYrACPExLH+U8Dl9j0 +aMLgfi+dXgymWP94QtLNh8C40UpXg4jVCG58rA70QTBh9AUZT2bTmOOA9DI5FVd/ +0OtcUa3y6GfF1CupPw4F9/uQyB+QsP78MpRYwc7zTEgdk1npmpymWD91F1Q5c8N6 +h8UAk3U170jb9QNJTZBwDW2M0TxvqjvvFyTXHPcZcQya7ZA9mNYsQaPdxOSSHlCt +AaZa3IXES2Kn+rGqaIxrMsKYRbLuGIP4RnoI4fWqxAHZ+HMb4AgMHsF2a0GzQxQV +isrTkSJ52JC2rMAYh3Kz780vDf8Eo5ar23oVCJfWGrWrU8pMYVKv82zF253h +-----END RSA PRIVATE KEY----- diff --git a/experimental/packages/exporter-logs-otlp-grpc/test/certs/client.crt b/experimental/packages/exporter-logs-otlp-grpc/test/certs/client.crt new file mode 100644 index 0000000000..cb5c4508d7 --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/test/certs/client.crt @@ -0,0 +1,31 @@ +-----BEGIN CERTIFICATE----- +MIIFPzCCAycCAQEwDQYJKoZIhvcNAQELBQAwYTELMAkGA1UEBhMCQ0wxCzAJBgNV +BAgMAlJNMRowGAYDVQQHDBFPcGVuVGVsZW1ldHJ5VGVzdDENMAsGA1UECgwEUm9v +dDENMAsGA1UECwwEVGVzdDELMAkGA1UEAwwCY2EwHhcNMjIwNjA4MDk1NDAxWhcN +MjMwNjA4MDk1NDAxWjBqMQswCQYDVQQGEwJDTDELMAkGA1UECAwCUk0xGjAYBgNV +BAcMEU9wZW5UZWxlbWV0cnlUZXN0MQ0wCwYDVQQKDARUZXN0MQ8wDQYDVQQLDAZD +bGllbnQxEjAQBgNVBAMMCWxvY2FsaG9zdDCCAiIwDQYJKoZIhvcNAQEBBQADggIP +ADCCAgoCggIBAMo9AlVbqKk0NI3U4IPhXARrA/9HCtW6TK8bNj+KqBETPJ0OV6Ep +FC1AUG8h6ZpQy1lAVchMOXXzVIxejJ53Wq2aBMELl7KaheEUAzbQNqSBxL7cY61l +sk1rd0ryQ0167j/tNV5h3FH4ZawD7vt2oGte4Dxipj+gFQx/MXD1j2vOKm0SO6xr +IdSWg79HRnMb6mJMCtTc6kvX5XDN3avwrhndsPKZREhs1ei6lhY4ip3N70357MB6 +vNF7euAMQU7KZ0uZZbj0lqINT+6jwEJ6yhkZM9ILKbxC8+IAhCAOsu2bKXtkhDSN +V+3Jr3x8PRWlhlCitGt9a8/DlT0RIfcXQHRmY7hdnMqt+7vJio56oHcyv2+8ap+C +rWr5OfsRuQvSs3ebn1zhDim0AspKOfdwGepPubgM/MuilYIi35L6CbRp+VbSGmIy +GUOGoWa3uykcMOm4hIK6bbFOGUTixbwIjRfxzuPfPLqIK+aQ5kBSUdDhK9LHpNOM +n0RihXBoRfE3VfnuWVcetp/FG7B5PTgCvP0Ss9QivTV/OQmi1juPa1ONmtZodZTz +eV2mDvZLQKFIInOQE/6dxMn+yrmYlQdV2nEiJU1yiKp5601OklqeX0BO1rWQy283 +AUwbAS5ZBmQeF4KmDZtEphdOTEDmu5YTyDhIvSK58Rq+iQq+CLmaYH3BAgMBAAEw +DQYJKoZIhvcNAQELBQADggIBABV90+TvW47WUdsZpy0eZayjWgIZvKqpWVcYI4Px +1zEGMVJvg8TPjPujGIdhkhxbabklqy/+s/im4ev9MnIGG0wckoYaJgH9KvtD/Br9 +3SpexmN9mQMO8/8299TWJBjS1q5UYjktvbuKFGpizs3+y4n88UmcXRh8y2Z1oglZ +WuXn5A5BJkpXONI3U615mXTf0CLnpbU//4z5VQe2AylksOgo3y7DHXz3iPOh15TN +EnDz7Pms0i8tswSbmS+NU2Clv7ACHhstdPoEqiN/V9gpjon1n+fBXaqMhaXI9C9b +NV9l5AW1utBAc/zlzRnKYtw/yrDW00KAN2FJbGefThJWPCYUlBx5hcCl1C8ObjIz +4b2+2TLdnwkMeeb8FV6mzTaQVWQ5Yr+ffQBqDhahEwjGyUOjzqFtGSlujWKLT4g1 +T9XnVr8KKU6UWDeHDp1lz8S9wo2l5DJN/S6u/SB9RXBOgzFVO9EWnbxkpR4YqdwK +WNP+Xhw9AO+DVX+/zK0PHF4f1z85E30R/V/CmvSx07jaXxK+ixcCykfb0DRvyVyr +WyVxz72LeJnsqWBSjBlwGslPsOzucA6RfN2b7/9rTObglKoKbEV/dSKoRZ34hFcV +nuiwRbVjVXH1az8FU8o+nG+anKW/jpVn4NcabYiHWH6qL+W3ZRTcWkyOOsSHHdOS +Hdil +-----END CERTIFICATE----- diff --git a/experimental/packages/exporter-logs-otlp-grpc/test/certs/client.csr b/experimental/packages/exporter-logs-otlp-grpc/test/certs/client.csr new file mode 100644 index 0000000000..30ac376794 --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/test/certs/client.csr @@ -0,0 +1,28 @@ +-----BEGIN CERTIFICATE REQUEST----- +MIIErzCCApcCAQAwajELMAkGA1UEBhMCQ0wxCzAJBgNVBAgMAlJNMRowGAYDVQQH +DBFPcGVuVGVsZW1ldHJ5VGVzdDENMAsGA1UECgwEVGVzdDEPMA0GA1UECwwGQ2xp +ZW50MRIwEAYDVQQDDAlsb2NhbGhvc3QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAw +ggIKAoICAQDKPQJVW6ipNDSN1OCD4VwEawP/RwrVukyvGzY/iqgREzydDlehKRQt +QFBvIemaUMtZQFXITDl181SMXoyed1qtmgTBC5eymoXhFAM20DakgcS+3GOtZbJN +a3dK8kNNeu4/7TVeYdxR+GWsA+77dqBrXuA8YqY/oBUMfzFw9Y9rziptEjusayHU +loO/R0ZzG+piTArU3OpL1+Vwzd2r8K4Z3bDymURIbNXoupYWOIqdze9N+ezAerzR +e3rgDEFOymdLmWW49JaiDU/uo8BCesoZGTPSCym8QvPiAIQgDrLtmyl7ZIQ0jVft +ya98fD0VpYZQorRrfWvPw5U9ESH3F0B0ZmO4XZzKrfu7yYqOeqB3Mr9vvGqfgq1q ++Tn7EbkL0rN3m59c4Q4ptALKSjn3cBnqT7m4DPzLopWCIt+S+gm0aflW0hpiMhlD +hqFmt7spHDDpuISCum2xThlE4sW8CI0X8c7j3zy6iCvmkOZAUlHQ4SvSx6TTjJ9E +YoVwaEXxN1X57llXHrafxRuweT04Arz9ErPUIr01fzkJotY7j2tTjZrWaHWU83ld +pg72S0ChSCJzkBP+ncTJ/sq5mJUHVdpxIiVNcoiqeetNTpJanl9ATta1kMtvNwFM +GwEuWQZkHheCpg2bRKYXTkxA5ruWE8g4SL0iufEavokKvgi5mmB9wQIDAQABoAAw +DQYJKoZIhvcNAQELBQADggIBAGsOxCfMBI11h5BOvDgKpVlAhxHlwyitXGPQHcsr +tjOQi0CRnkcrUMZcgnjX3OPCD3ngjZJW02m82BrN7WJJpSLzEKpnKP6Y91BXfHma +3qPFmMNkXCZ8WRjp6K/l98z9j+lFksN5y2BJCqf8oL1iURPYuHlgRK3LhpR4LOPt +JrJYwAML4hr1g93ejdwGc1LjNx8dyAriCM7h7IwhYGgnT1kYu/shVgT6SH0+ixAq +PNIOekCJH75k9C/QP/hPPARbAzD5of69haLeAcABik/cH/RRuDHTTVxgHFfV/W8r +BWwf7IIxX0iEPCQWxW1Q5SfzOmP9ICLFln4s38MgEGIyGqxgfkSi3nuLkwKTLB1j +NppTiO7Da4Vvso85hdLqNXvE3J6VSiu2c0oDf/ZZYkSizEzt9ESPPp3VcNj2MDbr +CxwhzV018wovlTunUSwKWvRn+syT10bnzZX/+QarZ7mfq57DPfMHNiiPM1ej26eE +Z7A3R3J67H4Ifp5Ua9jdga6x0RfOBRDuZv2N861eVs+9jSIC+hmrvQ1TbTvzHFVB +KYE1UBDRNijuGwsYgZ74vPKLGgA7cFs9X2JXzKc/0Y9opgBltZlNBF97XZSLDw1v +VaPCUVqOU6VKamPX8nVhkpHoUdDSl08T+VKwP5Da4oJHmSZMzxRQLl2TZnIru14+ +uVcP +-----END CERTIFICATE REQUEST----- diff --git a/experimental/packages/exporter-logs-otlp-grpc/test/certs/client.key b/experimental/packages/exporter-logs-otlp-grpc/test/certs/client.key new file mode 100644 index 0000000000..fd649acf54 --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/test/certs/client.key @@ -0,0 +1,51 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIJKQIBAAKCAgEAyj0CVVuoqTQ0jdTgg+FcBGsD/0cK1bpMrxs2P4qoERM8nQ5X +oSkULUBQbyHpmlDLWUBVyEw5dfNUjF6MnndarZoEwQuXspqF4RQDNtA2pIHEvtxj +rWWyTWt3SvJDTXruP+01XmHcUfhlrAPu+3aga17gPGKmP6AVDH8xcPWPa84qbRI7 +rGsh1JaDv0dGcxvqYkwK1NzqS9flcM3dq/CuGd2w8plESGzV6LqWFjiKnc3vTfns +wHq80Xt64AxBTspnS5lluPSWog1P7qPAQnrKGRkz0gspvELz4gCEIA6y7Zspe2SE +NI1X7cmvfHw9FaWGUKK0a31rz8OVPREh9xdAdGZjuF2cyq37u8mKjnqgdzK/b7xq +n4Ktavk5+xG5C9Kzd5ufXOEOKbQCyko593AZ6k+5uAz8y6KVgiLfkvoJtGn5VtIa +YjIZQ4ahZre7KRww6biEgrptsU4ZROLFvAiNF/HO4988uogr5pDmQFJR0OEr0sek +04yfRGKFcGhF8TdV+e5ZVx62n8UbsHk9OAK8/RKz1CK9NX85CaLWO49rU42a1mh1 +lPN5XaYO9ktAoUgic5AT/p3Eyf7KuZiVB1XacSIlTXKIqnnrTU6SWp5fQE7WtZDL +bzcBTBsBLlkGZB4XgqYNm0SmF05MQOa7lhPIOEi9IrnxGr6JCr4IuZpgfcECAwEA +AQKCAgAOu17+JM0mdj0Vz9oDAVmYoMsLv3sUkpufbdYHzuvrQoF511+ex8VGfpbd +YZUIvrXxbHRTQOo2o2EXUJPhv0QFvWB3R4bnZcY23SRWy9gPJ7zTQm6oZO4WIavw +87DfZgMQ+RCYLXzFI9kULL0t6DhLWf/vpigCHoEqBeHuHpUx/zSr+VYLe0pdmBFE +z8ZcAD6UpoFrfCQ9Hh8Clpx9N+0WyUVohq2osPTsHRttxvSiBixWe8w5QTeb8ujC +hWIEgU4A/c2hKYAHkfyun5MTxKoQJfvWYyXJJv9pCSyWwTtbf6AH8wyGX312Pujf +opU4jHQ6T3/hDKPb4J1wc10MCM+TCfF7aiBjOWkmJMJUxIpcKa8tCdeujFWnNbUo +zjdFPsa2Cpou84sal+uebQd0w/Qn7xRh093aHBI3Y2NINwBnpOK/hvV9Jo3nT1UT +EMiGP4okyhnG9BOKHJ7cuTVhH2Lezy6+4VyTsyVYvo5Zf4WUuimXcG3ibMJ17QoA +U2u5kJgNc0uJIhhGZIuIYKlVl9TjRtO6NYph+IppvFCqBL3rma/ytxl66Z6nSvSx +BwUvuHuDTEue6+L75KEiSF+Gj4WG5eIDdlEOh2/j65juPDLT0o3zYdwnCI0hDazS +h7ovGpBO9FQejES4c2+U/oBApoWwxcFdKW+7AW5oenleJhdJeQKCAQEA6Rgx+dnY +lyn5VTOJsCSupWnhQebleFco+SRBwB0DReqRyw8jdBP5YPJyHgvAxpCcZpowv59d +lLHSwl6k2zlkCBEIaSMXZYHawgt7Ht34ioGi0b6sOjGC87BTlC2YnKYD0dJy0C9b +8q2yq4EOgTCWUcubZNaOV+TjGrqh3LkHsOTki5cahEnR03p+GBTFW+JGOz1OGAYx +qt4xZuE+NpQY9ATqKdgRcd9TmHePm1ESNDdEMbawk3KpDyqjybEXuyWLg+KSh9wM +aNnRB5njOVHg8mgs3vmIQss+HTrfMZU74UbNFeiCeTag+dnjzwM/IKwdMIVAN+f8 +ZciA5jFFr1bgYwKCAQEA3hyVv0EaiERuYJS2Ibj769rTmUGItKKkfOa40OiHosXZ +1vx2CQUDcKcdsBn0ajX6nsib/NbV38FlE1tOvDhPPaMAkGDs2RU3y/cQtmEMh8wA +bTscOD7aJ7yhgtF/gZEprcqRcRsKTV3R4IKvTbGSFn2foSch/oVBdGk+3UU3zH6z +nGeyYYIe3y/k1EAHV3chCDTwk/XH75M9+R7MXeJ4t6OhAgKKT6XJnkTtujhXHMEM +aoqa9pejDFAHkhddXqSuGHlasqnInhOOwFRHgHNdJFp7Z/OHrit1VbltsK4+ZdC8 +LaJQpl3xOitXuc/D3yS5NQ+CsWQl5iLINsOUHxU4iwKCAQEArJAy/2udg1uZsM/0 +0Sh2+xLFpspPe6XbOYbz/kv8Tlh4EsJkVt0qs/EJNuEwmFAa2YKxMEvFNf3nr+nt +VjbIrYgel+dYvNdDooBpZ9Kg27lZVro4OuTIs6wIVBzlbKMjFMUeJq3I/oJFUd67 +ZD0aK/f2VNLakotq7jDY/9UjsnviDs2Q3frgkhWPIDjQW1PK9rROCk8bmgngvO9n +5XQCfTTePpgtYgYZlzh8YlnEhk+b9snvM1mhew7wLrMihHQpMzwbiuUHcuA+dcgh +hh/tzsf84B4QGJLqqy0Ya1a1+/M0hVGati4RQqdilbErnP6OpYsgncLrAldLxh8Y +HdTNTQKCAQEAp+ZJ2LKZIOtB2OZxq5pPbWIU1GQyuAG+f+BVUy6D4arYWmirvXO5 +vv3FNmrYVTWKx170c7PfJu7lvjUmlqemVvySH5H1WMBuVlPkoUlJlJnEtM2bLnVs +qd8w5FgDn+kg7YwUV8DOD9/dGG8Rn5Sczz2VXtfbHbCT4zDv4YpCfOZGVfQZZxZa +yfJFc6EXK6oVIUQLnH2N7u+KSHhcmpfpE0CxJHjRHxY/C9IlNsECMO1JunweWkwU +Z+lTX78jyLiKFlweELLBwaUdIwxSpKoQfbucT99K8IFPiEbMwWNmLccViRWLC8g1 +4vgCr6Z79YGoM5EPBZOkBozCdotvu/NpswKCAQAmEKgiBRnupScDQLE31QxSEyHZ +NUnheQ6SMYGjCrneD6LFgr8sK1iS8+PHjC4ngE40yh98speocH8oXgTfUap/7kcn +MEy70yZDGT2wGhcRVO4ivwwCP7NDic7eak22LF9QFn0qn0qAvU2NsdywtSBrRxPE +UF4uaTYs8gLTvlr+5qm5duk+P+hKL/OhOU9GQ3GMYbS/axTU7rkM1Mr+OM3oaKIZ +4Hz9JB0sGgrwpyXRnK4k5mjeUkJ9tx8a5Ky1pyd4Tob492+pdUJBsUXeqii8ZgKi +iCe4lWY9FnS13UC4AViWRaHu793h7xFoibevfXeqErByQ4ByDVPi2QJqIZcd +-----END RSA PRIVATE KEY----- diff --git a/experimental/packages/exporter-logs-otlp-grpc/test/certs/regenerate.sh b/experimental/packages/exporter-logs-otlp-grpc/test/certs/regenerate.sh new file mode 100755 index 0000000000..e1f1af5b54 --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/test/certs/regenerate.sh @@ -0,0 +1,22 @@ +#!/usr/bin/env sh +# +# Usage: regenerate.sh +# +# regenerate.sh regenerates certificates that are used to test gRPC with TLS +# Make sure you run it in test/certs directory. +# It also serves as a documentation on how existing certificates were generated. + +rm ca.crt ca.key client.crt client.csr client.key server.crt server.csr server.key + +openssl genrsa -nodes -des3 -out ca.key 4096 +openssl req -nodes -new -x509 -days 365 -key ca.key -out ca.crt -subj "/C=CL/ST=RM/L=OpenTelemetryTest/O=Root/OU=Test/CN=ca" + +openssl genrsa -nodes -des3 -out server.key 4096 +openssl req -nodes -new -key server.key -out server.csr -subj "/C=CL/ST=RM/L=OpenTelemetryTest/O=Test/OU=Server/CN=localhost" +openssl x509 -req -nodes -days 365 -in server.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out server.crt +openssl rsa -nodes -in server.key -out server.key + +openssl genrsa -nodes -des3 -out client.key 4096 +openssl req -nodes -new -key client.key -out client.csr -subj "/C=CL/ST=RM/L=OpenTelemetryTest/O=Test/OU=Client/CN=localhost" +openssl x509 -nodes -req -days 365 -in client.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out client.crt +openssl rsa -nodes -in client.key -out client.key diff --git a/experimental/packages/exporter-logs-otlp-grpc/test/certs/server.crt b/experimental/packages/exporter-logs-otlp-grpc/test/certs/server.crt new file mode 100644 index 0000000000..da8b6beedd --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/test/certs/server.crt @@ -0,0 +1,31 @@ +-----BEGIN CERTIFICATE----- +MIIFPzCCAycCAQEwDQYJKoZIhvcNAQELBQAwYTELMAkGA1UEBhMCQ0wxCzAJBgNV +BAgMAlJNMRowGAYDVQQHDBFPcGVuVGVsZW1ldHJ5VGVzdDENMAsGA1UECgwEUm9v +dDENMAsGA1UECwwEVGVzdDELMAkGA1UEAwwCY2EwHhcNMjIwNjA4MDk1NDAwWhcN +MjMwNjA4MDk1NDAwWjBqMQswCQYDVQQGEwJDTDELMAkGA1UECAwCUk0xGjAYBgNV +BAcMEU9wZW5UZWxlbWV0cnlUZXN0MQ0wCwYDVQQKDARUZXN0MQ8wDQYDVQQLDAZT +ZXJ2ZXIxEjAQBgNVBAMMCWxvY2FsaG9zdDCCAiIwDQYJKoZIhvcNAQEBBQADggIP +ADCCAgoCggIBAKF4wbhjwTd048CdtquNjhuVGIvPxpdNaCPXbSJN9joRqRwp0vt4 +DnRfLWda34UzZ9fxXN4HTgYrzLYkrdOUhvourhjka2mjcs1kOjlfFeGwgJe8LTVG +6qE+LdJFw4xPd53dZtsN1dQaj7e/GlK4jNI69qtq16dnFswjbzAI62or9MHdzY4F +fEFReMr25kGSo+/nNwI21PbiMhZ+OSTuoSgomx6JmXUYG9+uZFZTrE+fn47jMK4w +Bv1W+U2D1w2Aof01lyfQQ/giMY6XUAIPHIyBEvFyF1sdU+ZJzubl3vPGzf84If8+ +31iYsYEoqR3vwYs7+fmAWXOcXnjL8N0QqZPT37fsKLF1l+WCxhWLMlc8x9Kq8Gez +mOJRrR3j5Ui+ux6TpQV3aIXj3ykUIeDIIwRPNsDrwzJLNG28YVMV1rz4+V2/MsQ4 +ML1MilP3ZB9uxUN391XulLxsQI0olv+LZqKYnqqeHbFDt61Hr4WmefqKqB4rlO1j +WH4SLCEykzToFQpK9MQpPmUJ2UZrudN3flJGZ8bpnGu2gA2rgqfejB52D5jpZTzT +RU9OZp1v6JWjjRh3vcqVSin0mPLEXQj11cpKOBzIBEjqoPtpnjH8SQd9mb7n/o5q +8gLSuTcOqn3lLH3DvLTBilsmNcIbBItpC6QGc5EVqPlAJKIvLvOGb6B5AgMBAAEw +DQYJKoZIhvcNAQELBQADggIBAEdYvhg/TGjtzlJIqUv1qfyJr6gOm9Ydoz1WDaau +HJTkmI7vCeHUDxnhXEq1lYKt89XvUHsfI0lkCV2Gt+wppsL3ZZIGsv0C70nIPTIT +egPoBeUpqk1ZtPN3VEvgD3GDjAJzuvaL1Uhw9Yt4qKxP6ozyRfhObbTSomLNplui +LGGd6PqVF1vDAx6Ubw/LaNQzVjzQsMm4AgafakIh4c9aA3zxyZvUwAvT7ZVElMHK +moEudZQzL9Cx/Y9Pgv+z3JcXpT7UbDWSB/dVi5ZgcTtzHaYKAMFaunxNYqwWoicf +zB1uk2QOLgfxteWBjeaNl9UfXShGm+iGRoVVL7VrayO6+ScGchUGN5h1qR4xzWpA +2QKSb7t1oEW/GtrV6AD3jJUjcna4LP6DdpY/0IocgU5KonR0eFUNrZA8hUsXquQ0 +/Cx9d7ktdEDudeS4tJywF1CI3IcIZQ2vExJ+NjdlAFIVFkaqFFLhv/cCcGaBpH7X +6dc5bOoqyOgX97yBJJX9Joz6ZoAp2XO1tvycxj2g84V90lDsbTurmyuoR8yTcBbE +FNseKWNRi4fmsB1etz/HX3h1qUPP1ze+fY4C2zPleIB6uSKM5ZfODpMDejHQRF29 +YshoFbAJ19zOHYY+5LYHoLGJlN34TJ4ouPpAtRIQu4ebQZwMxddU1759sCIIwkHe +V5d5 +-----END CERTIFICATE----- diff --git a/experimental/packages/exporter-logs-otlp-grpc/test/certs/server.csr b/experimental/packages/exporter-logs-otlp-grpc/test/certs/server.csr new file mode 100644 index 0000000000..d8ab7deb4b --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/test/certs/server.csr @@ -0,0 +1,28 @@ +-----BEGIN CERTIFICATE REQUEST----- +MIIErzCCApcCAQAwajELMAkGA1UEBhMCQ0wxCzAJBgNVBAgMAlJNMRowGAYDVQQH +DBFPcGVuVGVsZW1ldHJ5VGVzdDENMAsGA1UECgwEVGVzdDEPMA0GA1UECwwGU2Vy +dmVyMRIwEAYDVQQDDAlsb2NhbGhvc3QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAw +ggIKAoICAQCheMG4Y8E3dOPAnbarjY4blRiLz8aXTWgj120iTfY6EakcKdL7eA50 +Xy1nWt+FM2fX8VzeB04GK8y2JK3TlIb6Lq4Y5Gtpo3LNZDo5XxXhsICXvC01Ruqh +Pi3SRcOMT3ed3WbbDdXUGo+3vxpSuIzSOvaratenZxbMI28wCOtqK/TB3c2OBXxB +UXjK9uZBkqPv5zcCNtT24jIWfjkk7qEoKJseiZl1GBvfrmRWU6xPn5+O4zCuMAb9 +VvlNg9cNgKH9NZcn0EP4IjGOl1ACDxyMgRLxchdbHVPmSc7m5d7zxs3/OCH/Pt9Y +mLGBKKkd78GLO/n5gFlznF54y/DdEKmT09+37CixdZflgsYVizJXPMfSqvBns5ji +Ua0d4+VIvrsek6UFd2iF498pFCHgyCMETzbA68MySzRtvGFTFda8+PldvzLEODC9 +TIpT92QfbsVDd/dV7pS8bECNKJb/i2aimJ6qnh2xQ7etR6+Fpnn6iqgeK5TtY1h+ +EiwhMpM06BUKSvTEKT5lCdlGa7nTd35SRmfG6ZxrtoANq4Kn3owedg+Y6WU800VP +Tmadb+iVo40Yd73KlUop9JjyxF0I9dXKSjgcyARI6qD7aZ4x/EkHfZm+5/6OavIC +0rk3Dqp95Sx9w7y0wYpbJjXCGwSLaQukBnORFaj5QCSiLy7zhm+geQIDAQABoAAw +DQYJKoZIhvcNAQELBQADggIBADoGwPR/TLe0PwsB2orIjrHnsZLYzcHxh9JdRaCO +Q07NvbocAqN3nIiHaUI/IqZG3aiBQb7i98maE2fcFVgsMoRVLB2GsQw+bzoPF+45 +kbtff4L1mHEt8AIIL063AepTetAMUfojpoRI0JG6pChzHDxuud++kPrz50wR5eEk +OhDjX46qh8VxExH3rfU+VDY/FvXMJaMLa76HOmY93g/p+C6T+SiTrs+QEPqWsMKa +eHJTTP0PZx8ikdT64aJpDiOmXVthymPPSZvDEWzlJ7RF8y0p+SoqPM3Pv8/M7zq7 +2dRL6UABTMGtBMEtj5DDZYWTl+1O8Yn4xhjHBcDT3ug3IvnCKCpX2ufi+wJzaWEu +QFAL+N5Sc1rZxklqWKprQeGBiEIE3UXdDA6Xvom85gLoaWoH6nMFvDNab+zJl4Ty +0Iiciq9jzUq4eda/TjgPxDs6RNlJxSXs1lASUR0Jx+Nb9wH2R1n6XQJhcOrz6nJ/ +T+/INYf5VrUdvf9P0PRub7Ga962fBDUG6WQx3PPjy/iEmffN/nsBXXzvQiw7ObW4 +eNCQob2H/3lAdxOs2txKhTCgUV9CzUb2P4Uq4s26n0yA6qpVG6Jgp14s+kVrgFYQ +KjhoFMWXtN3YqETnVNe6A9PEwkSpCm/JyGTm524ok0KyrXo1nSm1WKZqEIQCpp2D +vQFY +-----END CERTIFICATE REQUEST----- diff --git a/experimental/packages/exporter-logs-otlp-grpc/test/certs/server.key b/experimental/packages/exporter-logs-otlp-grpc/test/certs/server.key new file mode 100644 index 0000000000..9147802e7d --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/test/certs/server.key @@ -0,0 +1,51 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIJKAIBAAKCAgEAoXjBuGPBN3TjwJ22q42OG5UYi8/Gl01oI9dtIk32OhGpHCnS ++3gOdF8tZ1rfhTNn1/Fc3gdOBivMtiSt05SG+i6uGORraaNyzWQ6OV8V4bCAl7wt +NUbqoT4t0kXDjE93nd1m2w3V1BqPt78aUriM0jr2q2rXp2cWzCNvMAjraiv0wd3N +jgV8QVF4yvbmQZKj7+c3AjbU9uIyFn45JO6hKCibHomZdRgb365kVlOsT5+fjuMw +rjAG/Vb5TYPXDYCh/TWXJ9BD+CIxjpdQAg8cjIES8XIXWx1T5knO5uXe88bN/zgh +/z7fWJixgSipHe/Bizv5+YBZc5xeeMvw3RCpk9Pft+wosXWX5YLGFYsyVzzH0qrw +Z7OY4lGtHePlSL67HpOlBXdohePfKRQh4MgjBE82wOvDMks0bbxhUxXWvPj5Xb8y +xDgwvUyKU/dkH27FQ3f3Ve6UvGxAjSiW/4tmopieqp4dsUO3rUevhaZ5+oqoHiuU +7WNYfhIsITKTNOgVCkr0xCk+ZQnZRmu503d+UkZnxumca7aADauCp96MHnYPmOll +PNNFT05mnW/olaONGHe9ypVKKfSY8sRdCPXVyko4HMgESOqg+2meMfxJB32Zvuf+ +jmryAtK5Nw6qfeUsfcO8tMGKWyY1whsEi2kLpAZzkRWo+UAkoi8u84ZvoHkCAwEA +AQKCAgB16ox1TgvEpszHVaUXZJk5VUkGmKXqyfFZ8zDUU2CTiWAYnAZh84uCuhqb +FoaSbDbSQIVT8rus0AF/pgt2rklfnAUxUmWKUH0+tom6adC97roJlLbi6DXhqFmn +66Bg74tnsk4xe8oCSZ9YTOs5K2JTCBIoni58JlFEpD/HMUxRTWZAyOwaYbEathdj +CKifjCnBwPSv3kDpRcfUGzs52DXB8N1OkKeLFh8M2vqU/CeiQewwWYKsQZBpI0GN +tNCwIJarJZ6LyZBJPRc5jRA1YLm1dXDS90FNHX6udonsnkORfEXksiZJkq1hsqg1 +rO7LWNHbDuJ+rJcmUTPAPRZZKZjbnXEd9dHIPu/fg+vKUa/xuIkpaY5ZuV+SGMpg +QOHknz8mIOMAvnz1emAsR/yEflCN+ht5nmpwDnmVBNGSUV8D+8UgSLFWIFiqszJT +VNaYhUjEN6fR+VZ9WqF8jt9ZbnvfQipWkHVoGnA/bU+wb1duogVFfiKzHr1xyZzg +wG23vEIoXGhgHpTmZTjdQI3oc67TlAfCq6s6onI5z52xPn1O5Lk9H/7bIeEhvDWJ +1h9t7vcENk4RJNVh6gOEsuH/ECztWEXc7Nkv/8keJORuE50EOjwmc532aKEjqUCQ +6c7v28P3/n9XYZCG6K9mKlV1uK8Nhp4j4hVKyr+/uOgAAJq7AQKCAQEAzR97NpjH +7Bdy+ij+r8LpcUzkf3y1f+s3LABB4AjA2viVZP1CZIWpOli5JBEMo7rXUFmrVGUs +fMlyCxlc4PWDMIOkPn9GPmVUuuYQPjlM7ZZ8seLyBut/qHUBGbEKiKsuYkXAmOE1 +lVIJxyc1e39UxM+wL3PCwHKfSOjhFSOmMea8kzDBko5H4/os+l0vWUUQm+MreI6v +aqNPBKwwUxUyf3KVaB4BC7+2X/WIFNVzPQbYP0FmdesRYeA86JMSxWusP8NEIG71 +bhRGbvar4YSlgzgoX/vMDiR1EIIDSsAx5RL+xkjBCt4fqx5TdrszX1QLqFSmRwgF +8RkXVC8HG/vFGQKCAQEAyYWWipxWdhQnTkZ560BA4xSwX6usIHfoejbhcWdeMs8w +kH0ZmOnZFlZZ5hn+j6DY68q2OqQphbnutU5HOpc9vLUZjni72ZFSq6+fgxa8FQHm +j5VXeQ/NNxV9xjoEBV9/+CPbwBLAkSxd/luCyoU8cpwDxwMzJ638Z06yCY5jdDup +hT7OKw9HY4HUtJECGl2R3XdB8Gd/CnG22+coIGPFJSeY+5sOx35jkUgCApQl0QC3 +YS9v9IXVyyQVVN8eELoRFvjaty42n4rfYuS+bKe5MAOaAmkpRmXw8EZp/I/64jnh +ZjkQpEckvwnv9jLNfzRvedi+6WOY9/A2K9SjtrXCYQKCAQBV+x87uHj85qtkXvC7 +Hfmaa3/QTKcL0r3SrNzwGts0LkT5CwvcdQaFlZEtpBPnQbdlT+D4RFyMhihOrLf4 ++BCgsl2TcOgx2WnV2f/vBTfQ02a7bgTDj814AGuQqFxhA1gzC0f7DVPXnobIuw+5 +D5upz+DrUxvMbX+FIVDP+px8iFp9XE+XrhpGXqSh4ZOqWL/oiCW9qBmxmnjR3Zd4 +DAeZ0p78AK+xjA/XU2VSTlK6vvbANRrMzNcBbuw5FQUmScbvB1u0OK6aENehRbaw +lliGk3ChIzvapb+IRuc4Wy3O9tJirTZ15rvhj5muyDN1fxZP3gPA/IT5FepoeDoD +qdppAoIBABgz6huloSC3VO0qu7PMWL6tGm2zEY4ouIwNEVBsaLzTc3K3A58A3ui2 +4D8pehBH8iWHiBFM7Au6g/fUeeuIhIqoeXRJ/c2ojXQ/OHom/dnMC6PM/N92TWBD +PYLULu1yRc1IiTjtR6Fn4bYNyYyHKfZd1HpPYRJv6/OAWROavUkVbUuqelpjkGBc +FG7HR6hg+obNruavl2tqstqATapuMRxAQDhfrAu7mzu0mUE0B8KtQljyuJB2jnHC +WKmDznmVzz2iD6qWa0sIA8I91Lz5+9zPYezOMn3Y+nHxEwOZSzlmWDLNwbjpLnmf +OOmpulJ/uq+4n10qcBG/ENJ8zFjCRaECggEBALwBdMtxRd3YimcfYKMUPmLgNHY8 +GqIcRZ4QhboUbuhB2ykn3WnXNpF7SH8UQBVxUmusyxdZ4NWWpQ7CqvqpPL54cW/r +qZUb5S4qPN03sv+yZwQYohqzAZci/uexeltezmQ704WxUUdcL5uQoRsTqDm32+pN +/DQHvENLDqaDuN9hp7daFKdcq4mLFoXYm5aoA76yhxQI0EBhYjMiHz6PDZ8lzi+F +NduMOC9rcW2StDRyO++BcCexBjTSo7nlYbpO5kWW9VlC5TAabh8JL5+GJ9uT90Vf +GNqYVneFCCnsGeqJIXkzKn7eeygKjf6KCX94OA3O4z4ro/H+Gllv6eKSipc= +-----END RSA PRIVATE KEY----- diff --git a/experimental/packages/exporter-logs-otlp-grpc/test/logsHelper.ts b/experimental/packages/exporter-logs-otlp-grpc/test/logsHelper.ts new file mode 100644 index 0000000000..b57b2682bd --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/test/logsHelper.ts @@ -0,0 +1,173 @@ +/* + * 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 { HrTime, TraceFlags } from '@opentelemetry/api'; +import { SeverityNumber } from '@opentelemetry/api-logs'; +import { Resource } from '@opentelemetry/resources'; +import * as assert from 'assert'; +import * as grpc from '@grpc/grpc-js'; +import { VERSION } from '@opentelemetry/core'; +import { + IAnyValue, + IKeyValue, + ILogRecord, + IResource, +} from '@opentelemetry/otlp-transformer'; +import { ReadableLogRecord } from '@opentelemetry/sdk-logs'; + +const traceIdArr = [ + 31, 16, 8, 220, 142, 39, 14, 133, 196, 10, 13, 124, 57, 57, 178, 120, +]; +const spanIdArr = [94, 16, 114, 97, 246, 79, 165, 62]; + +export const mockedReadableLogRecord: ReadableLogRecord = { + resource: Resource.default().merge( + new Resource({ + 'resource-attribute': 'some resource-attr value', + }) + ), + instrumentationScope: { + name: 'scope_name_1', + version: '0.1.0', + schemaUrl: 'http://url.to.schema', + }, + hrTime: [1680253513, 123241635] as HrTime, + attributes: { + 'some-attribute': 'some attribute value', + }, + severityNumber: SeverityNumber.ERROR, + severityText: 'error', + body: 'some_log_body', + spanContext: { + traceFlags: TraceFlags.SAMPLED, + traceId: '1f1008dc8e270e85c40a0d7c3939b278', + spanId: '5e107261f64fa53e', + }, +}; + +export function ensureExportedAttributesAreCorrect(attributes: IKeyValue[]) { + assert.deepStrictEqual( + attributes, + [ + { + key: 'some-attribute', + value: { + stringValue: 'some attribute value', + value: 'stringValue', + }, + }, + ], + 'exported attributes are incorrect' + ); +} + +export function ensureExportedBodyIsCorrect(body?: IAnyValue) { + assert.deepStrictEqual( + body, + { stringValue: 'some_log_body', value: 'stringValue' }, + 'exported attributes are incorrect' + ); +} + +export function ensureExportedLogRecordIsCorrect(logRecord: ILogRecord) { + ensureExportedBodyIsCorrect(logRecord.body); + ensureExportedAttributesAreCorrect(logRecord.attributes); + assert.strictEqual( + logRecord.timeUnixNano, + '1680253513123241728', + 'timeUnixNano is wrong' + ); + assert.strictEqual( + logRecord.observedTimeUnixNano, + '1680253513123241728', + 'observedTimeUnixNano is wrong' + ); + assert.strictEqual( + logRecord.severityNumber, + 'SEVERITY_NUMBER_ERROR', + 'severityNumber is wrong' + ); + assert.strictEqual(logRecord.severityText, 'error', 'severityText is wrong'); + assert.strictEqual( + logRecord.droppedAttributesCount, + 0, + 'droppedAttributesCount is wrong' + ); + assert.strictEqual(logRecord.flags, TraceFlags.SAMPLED, 'flags is wrong'); + assert.deepStrictEqual( + logRecord.traceId, + Buffer.from(traceIdArr), + 'traceId is wrong' + ); + assert.deepStrictEqual( + logRecord.spanId, + Buffer.from(spanIdArr), + 'spanId is wrong' + ); +} + +export function ensureResourceIsCorrect(resource: IResource) { + assert.deepStrictEqual(resource, { + attributes: [ + { + key: 'service.name', + value: { + stringValue: `unknown_service:${process.argv0}`, + value: 'stringValue', + }, + }, + { + key: 'telemetry.sdk.language', + value: { + stringValue: 'nodejs', + value: 'stringValue', + }, + }, + { + key: 'telemetry.sdk.name', + value: { + stringValue: 'opentelemetry', + value: 'stringValue', + }, + }, + { + key: 'telemetry.sdk.version', + value: { + stringValue: VERSION, + value: 'stringValue', + }, + }, + { + key: 'resource-attribute', + value: { + stringValue: 'some resource-attr value', + value: 'stringValue', + }, + }, + ], + droppedAttributesCount: 0, + }); +} + +export function ensureMetadataIsCorrect( + actual?: grpc.Metadata, + expected?: grpc.Metadata +) { + //ignore user agent + expected?.remove('user-agent'); + actual?.remove('user-agent'); + assert.deepStrictEqual(actual?.getMap(), expected?.getMap() ?? {}); +} diff --git a/experimental/packages/exporter-logs-otlp-grpc/tsconfig.json b/experimental/packages/exporter-logs-otlp-grpc/tsconfig.json new file mode 100644 index 0000000000..cd64d1ce73 --- /dev/null +++ b/experimental/packages/exporter-logs-otlp-grpc/tsconfig.json @@ -0,0 +1,37 @@ +{ + "extends": "../../../tsconfig.base.json", + "compilerOptions": { + "outDir": "build", + "rootDir": "." + }, + "include": [ + "src/**/*.ts", + "test/**/*.ts" + ], + "references": [ + { + "path": "../../../api" + }, + { + "path": "../../../packages/opentelemetry-core" + }, + { + "path": "../../../packages/opentelemetry-resources" + }, + { + "path": "../api-logs" + }, + { + "path": "../otlp-exporter-base" + }, + { + "path": "../otlp-grpc-exporter-base" + }, + { + "path": "../otlp-transformer" + }, + { + "path": "../sdk-logs" + } + ] +} diff --git a/packages/opentelemetry-core/src/utils/environment.ts b/packages/opentelemetry-core/src/utils/environment.ts index 45fd67d9f3..1ab79176da 100644 --- a/packages/opentelemetry-core/src/utils/environment.ts +++ b/packages/opentelemetry-core/src/utils/environment.ts @@ -58,6 +58,7 @@ const ENVIRONMENT_NUMBERS_KEYS = [ 'OTEL_EXPORTER_OTLP_TIMEOUT', 'OTEL_EXPORTER_OTLP_TRACES_TIMEOUT', 'OTEL_EXPORTER_OTLP_METRICS_TIMEOUT', + 'OTEL_EXPORTER_OTLP_LOGS_TIMEOUT', 'OTEL_EXPORTER_JAEGER_AGENT_PORT', ] as const; @@ -98,9 +99,11 @@ export type ENVIRONMENT = { OTEL_EXPORTER_OTLP_ENDPOINT?: string; OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?: string; OTEL_EXPORTER_OTLP_METRICS_ENDPOINT?: string; + OTEL_EXPORTER_OTLP_LOGS_ENDPOINT?: string; OTEL_EXPORTER_OTLP_HEADERS?: string; OTEL_EXPORTER_OTLP_TRACES_HEADERS?: string; OTEL_EXPORTER_OTLP_METRICS_HEADERS?: string; + OTEL_EXPORTER_OTLP_LOGS_HEADERS?: string; OTEL_EXPORTER_ZIPKIN_ENDPOINT?: string; OTEL_LOG_LEVEL?: DiagLogLevel; OTEL_RESOURCE_ATTRIBUTES?: string; @@ -112,21 +115,27 @@ export type ENVIRONMENT = { OTEL_EXPORTER_OTLP_INSECURE?: string; OTEL_EXPORTER_OTLP_TRACES_INSECURE?: string; OTEL_EXPORTER_OTLP_METRICS_INSECURE?: string; + OTEL_EXPORTER_OTLP_LOGS_INSECURE?: string; OTEL_EXPORTER_OTLP_CERTIFICATE?: string; OTEL_EXPORTER_OTLP_TRACES_CERTIFICATE?: string; OTEL_EXPORTER_OTLP_METRICS_CERTIFICATE?: string; + OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE?: string; OTEL_EXPORTER_OTLP_COMPRESSION?: string; OTEL_EXPORTER_OTLP_TRACES_COMPRESSION?: string; OTEL_EXPORTER_OTLP_METRICS_COMPRESSION?: string; + OTEL_EXPORTER_OTLP_LOGS_COMPRESSION?: string; OTEL_EXPORTER_OTLP_CLIENT_KEY?: string; OTEL_EXPORTER_OTLP_TRACES_CLIENT_KEY?: string; OTEL_EXPORTER_OTLP_METRICS_CLIENT_KEY?: string; + OTEL_EXPORTER_OTLP_LOGS_CLIENT_KEY?: string; OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE?: string; OTEL_EXPORTER_OTLP_TRACES_CLIENT_CERTIFICATE?: string; OTEL_EXPORTER_OTLP_METRICS_CLIENT_CERTIFICATE?: string; + OTEL_EXPORTER_OTLP_LOGS_CLIENT_CERTIFICATE?: string; OTEL_EXPORTER_OTLP_PROTOCOL?: string; OTEL_EXPORTER_OTLP_TRACES_PROTOCOL?: string; OTEL_EXPORTER_OTLP_METRICS_PROTOCOL?: string; + OTEL_EXPORTER_OTLP_LOGS_PROTOCOL?: string; OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE?: string; } & ENVIRONMENT_BOOLEANS & ENVIRONMENT_NUMBERS & @@ -170,12 +179,15 @@ export const DEFAULT_ENVIRONMENT: Required = { OTEL_EXPORTER_OTLP_ENDPOINT: '', OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: '', OTEL_EXPORTER_OTLP_METRICS_ENDPOINT: '', + OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: '', OTEL_EXPORTER_OTLP_HEADERS: '', OTEL_EXPORTER_OTLP_TRACES_HEADERS: '', OTEL_EXPORTER_OTLP_METRICS_HEADERS: '', + OTEL_EXPORTER_OTLP_LOGS_HEADERS: '', OTEL_EXPORTER_OTLP_TIMEOUT: 10000, OTEL_EXPORTER_OTLP_TRACES_TIMEOUT: 10000, OTEL_EXPORTER_OTLP_METRICS_TIMEOUT: 10000, + OTEL_EXPORTER_OTLP_LOGS_TIMEOUT: 10000, OTEL_EXPORTER_ZIPKIN_ENDPOINT: 'http://localhost:9411/api/v2/spans', OTEL_LOG_LEVEL: DiagLogLevel.INFO, OTEL_NO_PATCH_MODULES: [], @@ -202,21 +214,27 @@ export const DEFAULT_ENVIRONMENT: Required = { OTEL_EXPORTER_OTLP_INSECURE: '', OTEL_EXPORTER_OTLP_TRACES_INSECURE: '', OTEL_EXPORTER_OTLP_METRICS_INSECURE: '', + OTEL_EXPORTER_OTLP_LOGS_INSECURE: '', OTEL_EXPORTER_OTLP_CERTIFICATE: '', OTEL_EXPORTER_OTLP_TRACES_CERTIFICATE: '', OTEL_EXPORTER_OTLP_METRICS_CERTIFICATE: '', + OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE: '', OTEL_EXPORTER_OTLP_COMPRESSION: '', OTEL_EXPORTER_OTLP_TRACES_COMPRESSION: '', OTEL_EXPORTER_OTLP_METRICS_COMPRESSION: '', + OTEL_EXPORTER_OTLP_LOGS_COMPRESSION: '', OTEL_EXPORTER_OTLP_CLIENT_KEY: '', OTEL_EXPORTER_OTLP_TRACES_CLIENT_KEY: '', OTEL_EXPORTER_OTLP_METRICS_CLIENT_KEY: '', + OTEL_EXPORTER_OTLP_LOGS_CLIENT_KEY: '', OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE: '', OTEL_EXPORTER_OTLP_TRACES_CLIENT_CERTIFICATE: '', OTEL_EXPORTER_OTLP_METRICS_CLIENT_CERTIFICATE: '', + OTEL_EXPORTER_OTLP_LOGS_CLIENT_CERTIFICATE: '', OTEL_EXPORTER_OTLP_PROTOCOL: 'http/protobuf', OTEL_EXPORTER_OTLP_TRACES_PROTOCOL: 'http/protobuf', OTEL_EXPORTER_OTLP_METRICS_PROTOCOL: 'http/protobuf', + OTEL_EXPORTER_OTLP_LOGS_PROTOCOL: 'http/protobuf', OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE: 'cumulative', }; diff --git a/tsconfig.json b/tsconfig.json index e54ecaeff9..e29f43f52e 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -7,6 +7,7 @@ "api", "experimental/packages/api-events", "experimental/packages/api-logs", + "experimental/packages/exporter-logs-otlp-grpc", "experimental/packages/exporter-trace-otlp-grpc", "experimental/packages/exporter-trace-otlp-http", "experimental/packages/exporter-trace-otlp-proto", @@ -62,6 +63,9 @@ { "path": "experimental/packages/api-logs" }, + { + "path": "experimental/packages/exporter-logs-otlp-grpc" + }, { "path": "experimental/packages/exporter-trace-otlp-grpc" }, From 13efead22759564561196fbc4a0bf6d8720eb86f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Thu, 13 Apr 2023 20:57:27 +0800 Subject: [PATCH 07/16] chore: changelog update --- CHANGELOG.md | 2 ++ experimental/CHANGELOG.md | 4 ++++ 2 files changed, 6 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 55f17b5742..30c3a784ba 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,8 @@ For experimental package changes, see the [experimental CHANGELOG](experimental/ ### :rocket: (Enhancement) +* feat(core): add environment variables for OTLP log exporters. [#3712](https://github.com/open-telemetry/opentelemetry-js/pull/3712/) @llc1123 + ### :bug: (Bug Fix) ### :books: (Refine Doc) diff --git a/experimental/CHANGELOG.md b/experimental/CHANGELOG.md index fbf8564590..e6fc16af0c 100644 --- a/experimental/CHANGELOG.md +++ b/experimental/CHANGELOG.md @@ -8,6 +8,10 @@ All notable changes to experimental packages in this project will be documented ### :rocket: (Enhancement) +* feat(otlp-transformer): support log records. [#3712](https://github.com/open-telemetry/opentelemetry-js/pull/3712/) @llc1123 +* feat(otlp-grpc-exporter-base): support log records. [#3712](https://github.com/open-telemetry/opentelemetry-js/pull/3712/) @llc1123 +* feat(exporter-logs-otlp-grpc): otlp-grpc exporter for logs. [#3712](https://github.com/open-telemetry/opentelemetry-js/pull/3712/) @llc1123 + ### :bug: (Bug Fix) ### :books: (Refine Doc) From a5ac019e64e749b6507457317b674b7748abc583 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Tue, 18 Apr 2023 16:29:26 +0800 Subject: [PATCH 08/16] chore(docs): refine docs of `exporter-logs-otlp-grpc` --- experimental/packages/exporter-logs-otlp-grpc/README.md | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/experimental/packages/exporter-logs-otlp-grpc/README.md b/experimental/packages/exporter-logs-otlp-grpc/README.md index fdfed3d38c..38a5dd8ab8 100644 --- a/experimental/packages/exporter-logs-otlp-grpc/README.md +++ b/experimental/packages/exporter-logs-otlp-grpc/README.md @@ -6,7 +6,7 @@ **Note: This is an experimental package under active development. New releases may include breaking changes.** This module provides exporter for node to be used with OTLP (`grpc`) compatible receivers. -Compatible with [opentelemetry-collector][opentelemetry-collector-url] versions `>=0.16 <=0.53`. +Compatible with [opentelemetry-collector][opentelemetry-collector-url] versions `>=0.75.0`. ## Installation @@ -75,11 +75,6 @@ logger.emit({ body: 'example-log' }); > Settings configured programmatically take precedence over environment variables. Per-signal environment variables take precedence over non-per-signal environment variables. -## Running opentelemetry-collector locally to see the logs - -1. Go to `examples/otlp-exporter-node` -2. Follow the instructions there to view logs. - ## Useful links - For more information on OpenTelemetry, visit: From 85b309cb7b357dbb3cfe76535d1ab1968f59d7ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Tue, 18 Apr 2023 17:46:24 +0800 Subject: [PATCH 09/16] Revert "refactor(otlp-transformer): improve code coverage for metrics" This reverts commit fdd06c6ff97bc8c16c716bdaae8f86a52137940a. --- .../otlp-transformer/src/metrics/internal.ts | 91 +++++++++---------- 1 file changed, 45 insertions(+), 46 deletions(-) diff --git a/experimental/packages/otlp-transformer/src/metrics/internal.ts b/experimental/packages/otlp-transformer/src/metrics/internal.ts index b73696b0ab..7ba7722b6a 100644 --- a/experimental/packages/otlp-transformer/src/metrics/internal.ts +++ b/experimental/packages/otlp-transformer/src/metrics/internal.ts @@ -44,21 +44,24 @@ export function toResourceMetrics( attributes: toAttributes(resourceMetrics.resource.attributes), droppedAttributesCount: 0, }, - schemaUrl: undefined, + schemaUrl: undefined, // TODO: Schema Url does not exist yet in the SDK. scopeMetrics: toScopeMetrics(resourceMetrics.scopeMetrics), }; } export function toScopeMetrics(scopeMetrics: ScopeMetrics[]): IScopeMetrics[] { return Array.from( - scopeMetrics.map(metrics => ({ - scope: { - name: metrics.scope.name, - version: metrics.scope.version, - }, - metrics: metrics.metrics.map(metricData => toMetric(metricData)), - schemaUrl: metrics.scope.schemaUrl, - })) + scopeMetrics.map(metrics => { + const scopeMetrics: IScopeMetrics = { + scope: { + name: metrics.scope.name, + version: metrics.scope.version, + }, + metrics: metrics.metrics.map(metricData => toMetric(metricData)), + schemaUrl: metrics.scope.schemaUrl, + }; + return scopeMetrics; + }) ); } @@ -73,31 +76,27 @@ export function toMetric(metricData: MetricData): IMetric { metricData.aggregationTemporality ); - switch (metricData.dataPointType) { - case DataPointType.SUM: - out.sum = { - aggregationTemporality, - isMonotonic: metricData.isMonotonic, - dataPoints: toSingularDataPoints(metricData), - }; - break; - case DataPointType.GAUGE: - out.gauge = { - dataPoints: toSingularDataPoints(metricData), - }; - break; - case DataPointType.HISTOGRAM: - out.histogram = { - aggregationTemporality, - dataPoints: toHistogramDataPoints(metricData), - }; - break; - case DataPointType.EXPONENTIAL_HISTOGRAM: - out.exponentialHistogram = { - aggregationTemporality, - dataPoints: toExponentialHistogramDataPoints(metricData), - }; - break; + if (metricData.dataPointType === DataPointType.SUM) { + out.sum = { + aggregationTemporality, + isMonotonic: metricData.isMonotonic, + dataPoints: toSingularDataPoints(metricData), + }; + } else if (metricData.dataPointType === DataPointType.GAUGE) { + // Instrument is a gauge. + out.gauge = { + dataPoints: toSingularDataPoints(metricData), + }; + } else if (metricData.dataPointType === DataPointType.HISTOGRAM) { + out.histogram = { + aggregationTemporality, + dataPoints: toHistogramDataPoints(metricData), + }; + } else if (metricData.dataPointType === DataPointType.EXPONENTIAL_HISTOGRAM) { + out.exponentialHistogram = { + aggregationTemporality, + dataPoints: toExponentialHistogramDataPoints(metricData), + }; } return out; @@ -116,13 +115,10 @@ function toSingularDataPoint( timeUnixNano: hrTimeToNanoseconds(dataPoint.endTime), }; - switch (valueType) { - case ValueType.INT: - out.asInt = dataPoint.value as number; - break; - case ValueType.DOUBLE: - out.asDouble = dataPoint.value as number; - break; + if (valueType === ValueType.INT) { + out.asInt = dataPoint.value as number; + } else if (valueType === ValueType.DOUBLE) { + out.asDouble = dataPoint.value as number; } return out; @@ -181,10 +177,13 @@ function toExponentialHistogramDataPoints( function toAggregationTemporality( temporality: AggregationTemporality ): EAggregationTemporality { - switch (temporality) { - case AggregationTemporality.DELTA: - return EAggregationTemporality.AGGREGATION_TEMPORALITY_DELTA; - case AggregationTemporality.CUMULATIVE: - return EAggregationTemporality.AGGREGATION_TEMPORALITY_CUMULATIVE; + if (temporality === AggregationTemporality.DELTA) { + return EAggregationTemporality.AGGREGATION_TEMPORALITY_DELTA; } + + if (temporality === AggregationTemporality.CUMULATIVE) { + return EAggregationTemporality.AGGREGATION_TEMPORALITY_CUMULATIVE; + } + + return EAggregationTemporality.AGGREGATION_TEMPORALITY_UNSPECIFIED; } From a93c87a97df993ea32c17656a5bb89f56d0c04b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Wed, 19 Apr 2023 21:26:28 +0800 Subject: [PATCH 10/16] fix(otlp-transformer): only types are imported from `sdk-logs` so removed from peerDependencies --- experimental/packages/otlp-transformer/package.json | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/experimental/packages/otlp-transformer/package.json b/experimental/packages/otlp-transformer/package.json index f5395a7ef0..7e917fd233 100644 --- a/experimental/packages/otlp-transformer/package.json +++ b/experimental/packages/otlp-transformer/package.json @@ -53,8 +53,7 @@ ], "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.5.0", - "@opentelemetry/api-logs": "0.38.0", - "@opentelemetry/sdk-logs": "0.38.0" + "@opentelemetry/api-logs": "0.38.0" }, "devDependencies": { "@opentelemetry/api": "1.4.1", From 33987731912d6b6e4ac3a22dec6e7a4d7c47d058 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Thu, 20 Apr 2023 17:33:36 +0800 Subject: [PATCH 11/16] fix(exporter-logs-otlp-grpc): update README --- experimental/packages/exporter-logs-otlp-grpc/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/experimental/packages/exporter-logs-otlp-grpc/README.md b/experimental/packages/exporter-logs-otlp-grpc/README.md index 38a5dd8ab8..78d1fdfeed 100644 --- a/experimental/packages/exporter-logs-otlp-grpc/README.md +++ b/experimental/packages/exporter-logs-otlp-grpc/README.md @@ -29,7 +29,7 @@ options that work with trace also work with logs. ```js import { LoggerProvider, - SimpleLogRecordProcessor, + BatchLogRecordProcessor, } from '@opentelemetry/sdk-logs'; import { OTLPLogsExporter } from '@opentelemetry/exporter-logs-otlp-grpc'; @@ -42,7 +42,7 @@ const loggerExpoter = new OTLPLogsExporter(collectorOptions); const loggerProvider = new LoggerProvider(); loggerProvider.addLogRecordProcessor( - new SimpleLogRecordProcessor(loggerExpoter) + new BatchLogRecordProcessor(loggerExpoter) ); ['SIGINT', 'SIGTERM'].forEach(signal => { From 1f041e192399178244e79a72fd58af08d072a05f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Thu, 20 Apr 2023 19:15:47 +0800 Subject: [PATCH 12/16] fix(exporter-logs-otlp-grpc): remove unused env vars --- experimental/packages/exporter-logs-otlp-grpc/README.md | 6 ------ 1 file changed, 6 deletions(-) diff --git a/experimental/packages/exporter-logs-otlp-grpc/README.md b/experimental/packages/exporter-logs-otlp-grpc/README.md index 78d1fdfeed..ce088cec3e 100644 --- a/experimental/packages/exporter-logs-otlp-grpc/README.md +++ b/experimental/packages/exporter-logs-otlp-grpc/README.md @@ -60,17 +60,11 @@ logger.emit({ body: 'example-log' }); |----------------------|-------------| | OTEL_EXPORTER_OTLP_LOGS_ENDPOINT | The endpoint to send logs to. By default `localhost:4317` will be used. | | OTEL_EXPORTER_OTLP_ENDPOINT | The endpoint to send trace, metric, and logs to. By default `localhost:4317` will be used. | -| OTEL_EXPORTER_OTLP_LOGS_COMPRESSION | The compression type to use on OTLP logs requests. Options include gzip. By default no compression will be used. | | OTEL_EXPORTER_OTLP_COMPRESSION | The compression type to use on OTLP trace, metric, and log requests. Options include gzip. By default no compression will be used. | -| OTEL_EXPORTER_OTLP_LOGS_INSECURE | Whether to enable client transport security for the exporter's gRPC connection for logs requests. This option only applies to OTLP/gRPC when an endpoint is provided without the http or https scheme. Options include true or false. By default insecure is false which creates a secure connection. | | OTEL_EXPORTER_OTLP_INSECURE | Whether to enable client transport security for the exporter's gRPC connection for trace, metric and log requests. This option only applies to OTLP/gRPC when an endpoint is provided without the http or https scheme. Options include true or false. By default insecure is false which creates a secure connection. | -| OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE | The path to the file containing trusted root certificate to use when verifying an OTLP logs server's TLS credentials. By default the host platform's trusted root certificate is used.| | OTEL_EXPORTER_OTLP_CERTIFICATE | The path to the file containing trusted root certificate to use when verifying an OTLP trace, metric, or log server's TLS credentials. By default the host platform's trusted root certificate is used. | -| OTEL_EXPORTER_OTLP_LOGS_CLIENT_KEY | The path to the file containing private client key to use when verifying an OTLP logs client's TLS credentials. Must provide a client certificate/chain when providing a private client key. By default no client key file is used. | | OTEL_EXPORTER_OTLP_CLIENT_KEY | The path to the file containing private client key to use when verifying an OTLP trace, metric or log client's TLS credentials. Must provide a client certificate/chain when providing a private client key. By default no client key file is used. | -| OTEL_EXPORTER_OTLP_LOGS_CLIENT_CERTIFICATE | The path to the file containing trusted client certificate/chain for clients private key to use when verifying an OTLP logs server's TLS credentials. Must provide a private client key when providing a certificate/chain. By default no chain file is used. | | OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE | The path to the file containing trusted client certificate/chain for clients private key to use when verifying an OTLP trace, metric and log server's TLS credentials. Must provide a private client key when providing a certificate/chain. By default no chain file is used. | -| OTEL_EXPORTER_OTLP_LOGS_TIMEOUT | The maximum waiting time, in milliseconds, allowed to send each OTLP logs batch. Default is 10000. | | OTEL_EXPORTER_OTLP_TIMEOUT | The maximum waiting time, in milliseconds, allowed to send each OTLP trace and metric batch. Default is 10000. | > Settings configured programmatically take precedence over environment variables. Per-signal environment variables take precedence over non-per-signal environment variables. From 1a2ab0f1f74f7bf7f9d1a0d399ba05e4bebb3fd4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Tue, 25 Apr 2023 02:25:06 +0800 Subject: [PATCH 13/16] fix(exporter-logs-otlp-grpc): update compatible collector version --- experimental/packages/exporter-logs-otlp-grpc/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/experimental/packages/exporter-logs-otlp-grpc/README.md b/experimental/packages/exporter-logs-otlp-grpc/README.md index ce088cec3e..27068a3162 100644 --- a/experimental/packages/exporter-logs-otlp-grpc/README.md +++ b/experimental/packages/exporter-logs-otlp-grpc/README.md @@ -6,7 +6,7 @@ **Note: This is an experimental package under active development. New releases may include breaking changes.** This module provides exporter for node to be used with OTLP (`grpc`) compatible receivers. -Compatible with [opentelemetry-collector][opentelemetry-collector-url] versions `>=0.75.0`. +Compatible with [opentelemetry-collector][opentelemetry-collector-url] versions `>=0.54.0`. ## Installation From 36b0c322cf2e38bf0ceaba8fc37a1c17d49d68b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Tue, 25 Apr 2023 12:22:44 +0800 Subject: [PATCH 14/16] fix(exporter-logs-otlp-grpc): typo Co-authored-by: Martin Kuba --- experimental/packages/exporter-logs-otlp-grpc/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/experimental/packages/exporter-logs-otlp-grpc/README.md b/experimental/packages/exporter-logs-otlp-grpc/README.md index 27068a3162..c40d4a5170 100644 --- a/experimental/packages/exporter-logs-otlp-grpc/README.md +++ b/experimental/packages/exporter-logs-otlp-grpc/README.md @@ -38,11 +38,11 @@ const collectorOptions = { url: 'http://:', }; -const loggerExpoter = new OTLPLogsExporter(collectorOptions); +const loggerExporter = new OTLPLogsExporter(collectorOptions); const loggerProvider = new LoggerProvider(); loggerProvider.addLogRecordProcessor( - new BatchLogRecordProcessor(loggerExpoter) + new BatchLogRecordProcessor(loggerExporter) ); ['SIGINT', 'SIGTERM'].forEach(signal => { From 3c27045e634806b492b5e63672bbd2cd94c67dd3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Tue, 25 Apr 2023 17:16:08 +0800 Subject: [PATCH 15/16] fix(exporter-logs-otlp-grpc): update collector version requirements in docs. Co-authored-by: Daniel Dyla --- experimental/packages/exporter-logs-otlp-grpc/README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/experimental/packages/exporter-logs-otlp-grpc/README.md b/experimental/packages/exporter-logs-otlp-grpc/README.md index c40d4a5170..dee62b496f 100644 --- a/experimental/packages/exporter-logs-otlp-grpc/README.md +++ b/experimental/packages/exporter-logs-otlp-grpc/README.md @@ -5,8 +5,7 @@ **Note: This is an experimental package under active development. New releases may include breaking changes.** -This module provides exporter for node to be used with OTLP (`grpc`) compatible receivers. -Compatible with [opentelemetry-collector][opentelemetry-collector-url] versions `>=0.54.0`. +This module provides an exporter for OTLP gRPC logs using protocol version `v0.18`. ## Installation From 4d9ef90bebf4a525631e832e49b7551d05447b85 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=B2=92=E7=B2=92=E6=A9=99?= Date: Tue, 25 Apr 2023 16:24:41 +0800 Subject: [PATCH 16/16] fix(exporter-logs-otlp-grpc): update dependencies --- experimental/packages/exporter-logs-otlp-grpc/package.json | 4 ++-- experimental/packages/otlp-transformer/package.json | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/experimental/packages/exporter-logs-otlp-grpc/package.json b/experimental/packages/exporter-logs-otlp-grpc/package.json index 313a19b7e3..b484723791 100644 --- a/experimental/packages/exporter-logs-otlp-grpc/package.json +++ b/experimental/packages/exporter-logs-otlp-grpc/package.json @@ -54,7 +54,6 @@ "@opentelemetry/api-logs": "0.38.0", "@opentelemetry/otlp-exporter-base": "0.38.0", "@opentelemetry/resources": "1.12.0", - "@opentelemetry/sdk-logs": "0.38.0", "@types/mocha": "10.0.0", "@types/node": "18.6.5", "@types/sinon": "10.0.13", @@ -75,7 +74,8 @@ "@grpc/grpc-js": "^1.7.1", "@opentelemetry/core": "1.12.0", "@opentelemetry/otlp-grpc-exporter-base": "0.38.0", - "@opentelemetry/otlp-transformer": "0.38.0" + "@opentelemetry/otlp-transformer": "0.38.0", + "@opentelemetry/sdk-logs": "0.38.0" }, "homepage": "https://github.com/open-telemetry/opentelemetry-js/tree/main/experimental/packages/exporter-logs-otlp-grpc", "sideEffects": false diff --git a/experimental/packages/otlp-transformer/package.json b/experimental/packages/otlp-transformer/package.json index 7e917fd233..be608f5ed5 100644 --- a/experimental/packages/otlp-transformer/package.json +++ b/experimental/packages/otlp-transformer/package.json @@ -58,7 +58,6 @@ "devDependencies": { "@opentelemetry/api": "1.4.1", "@opentelemetry/api-logs": "0.38.0", - "@opentelemetry/sdk-logs": "0.38.0", "@types/mocha": "10.0.0", "@types/webpack-env": "1.16.3", "codecov": "3.8.3", @@ -79,6 +78,7 @@ "dependencies": { "@opentelemetry/core": "1.12.0", "@opentelemetry/resources": "1.12.0", + "@opentelemetry/sdk-logs": "0.38.0", "@opentelemetry/sdk-metrics": "1.12.0", "@opentelemetry/sdk-trace-base": "1.12.0" },