diff --git a/packages/opentelemetry-exporter-collector/README.md b/packages/opentelemetry-exporter-collector/README.md index 6d27c508c1..30ed47caa4 100644 --- a/packages/opentelemetry-exporter-collector/README.md +++ b/packages/opentelemetry-exporter-collector/README.md @@ -49,6 +49,34 @@ provider.register(); ``` +By default, plaintext connection is used. In order to use TLS in Node.js, provide `credentials` option like so: +```js +const fs = require('fs'); +const grpc = require('grpc'); +const { BasicTracerProvider, SimpleSpanProcessor } = require('@opentelemetry/tracing'); +const { CollectorExporter } = require('@opentelemetry/exporter-collector'); + +const collectorOptions = { + serviceName: 'basic-service', + url: '', // url is optional and can be omitted - default is http://localhost:55678/v1/trace + credentials: grpc.credentials.createSsl( + fs.readFileSync('./ca.crt'), + fs.readFileSync('./client.key'), + fs.readFileSync('./client.crt') + ) +}; + +const provider = new BasicTracerProvider(); +const exporter = new CollectorExporter(collectorOptions); +provider.addSpanProcessor(new SimpleSpanProcessor(exporter)); + +provider.register(); +``` + +To see how to generate credentials, you can refer to the script used to generate certificates for tests [here](./test/certs/regenerate.sh) + +Note, that this will only work if TLS is also configured on the server. + ## Running opentelemetry-collector locally to see the traces 1. Go to examples/basic-tracer-node 2. run `npm run collector:docker:ot` diff --git a/packages/opentelemetry-exporter-collector/src/CollectorExporter.ts b/packages/opentelemetry-exporter-collector/src/CollectorExporterBase.ts similarity index 78% rename from packages/opentelemetry-exporter-collector/src/CollectorExporter.ts rename to packages/opentelemetry-exporter-collector/src/CollectorExporterBase.ts index 070042b121..5163451c90 100644 --- a/packages/opentelemetry-exporter-collector/src/CollectorExporter.ts +++ b/packages/opentelemetry-exporter-collector/src/CollectorExporterBase.ts @@ -14,16 +14,15 @@ * limitations under the License. */ +import { Attributes, Logger } from '@opentelemetry/api'; import { ExportResult, NoopLogger } from '@opentelemetry/core'; import { ReadableSpan, SpanExporter } from '@opentelemetry/tracing'; -import { Attributes, Logger } from '@opentelemetry/api'; -import { onInit, onShutdown, sendSpans } from './platform/index'; -import { opentelemetryProto } from './types'; +import { opentelemetryProto, CollectorExporterError } from './types'; /** - * Collector Exporter Config + * Collector Exporter base config */ -export interface CollectorExporterConfig { +export interface CollectorExporterConfigBase { hostName?: string; logger?: Logger; serviceName?: string; @@ -35,20 +34,22 @@ const DEFAULT_SERVICE_NAME = 'collector-exporter'; const DEFAULT_COLLECTOR_URL = 'http://localhost:55678/v1/trace'; /** - * Collector Exporter + * Collector Exporter abstract base class */ -export class CollectorExporter implements SpanExporter { - readonly serviceName: string; - readonly url: string; - readonly logger: Logger; - readonly hostName: string | undefined; - readonly attributes?: Attributes; +export abstract class CollectorExporterBase< + T extends CollectorExporterConfigBase +> implements SpanExporter { + public readonly serviceName: string; + public readonly url: string; + public readonly logger: Logger; + public readonly hostName: string | undefined; + public readonly attributes?: Attributes; private _isShutdown: boolean = false; /** * @param config */ - constructor(config: CollectorExporterConfig = {}) { + constructor(config: T = {} as T) { this.serviceName = config.serviceName || DEFAULT_SERVICE_NAME; this.url = config.url || DEFAULT_COLLECTOR_URL; if (typeof config.hostName === 'string') { @@ -62,7 +63,7 @@ export class CollectorExporter implements SpanExporter { this.shutdown = this.shutdown.bind(this); // platform dependent - onInit(this); + this.onInit(config); } /** @@ -105,7 +106,7 @@ export class CollectorExporter implements SpanExporter { this.logger.debug('spans to be sent', spans); // Send spans to [opentelemetry collector]{@link https://github.com/open-telemetry/opentelemetry-collector} // it will use the appropriate transport layer automatically depends on platform - sendSpans(spans, resolve, reject, this); + this.sendSpans(spans, resolve, reject); } catch (e) { reject(e); } @@ -124,6 +125,14 @@ export class CollectorExporter implements SpanExporter { this.logger.debug('shutdown started'); // platform dependent - onShutdown(this); + this.onShutdown(); } + + abstract onShutdown(): void; + abstract onInit(config: T): void; + abstract sendSpans( + spans: ReadableSpan[], + onSuccess: () => void, + onError: (error: CollectorExporterError) => void + ): void; } diff --git a/packages/opentelemetry-exporter-collector/src/index.ts b/packages/opentelemetry-exporter-collector/src/index.ts index df00fee615..c09b6b9bcb 100644 --- a/packages/opentelemetry-exporter-collector/src/index.ts +++ b/packages/opentelemetry-exporter-collector/src/index.ts @@ -1,5 +1,5 @@ /*! - * Copyright 2019, OpenTelemetry Authors + * Copyright 2020, OpenTelemetry Authors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,4 +14,4 @@ * limitations under the License. */ -export * from './CollectorExporter'; +export * from './platform'; diff --git a/packages/opentelemetry-exporter-collector/src/platform/browser/CollectorExporter.ts b/packages/opentelemetry-exporter-collector/src/platform/browser/CollectorExporter.ts new file mode 100644 index 0000000000..2a1a90d13d --- /dev/null +++ b/packages/opentelemetry-exporter-collector/src/platform/browser/CollectorExporter.ts @@ -0,0 +1,115 @@ +/*! + * Copyright 2020, 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 { + CollectorExporterBase, + CollectorExporterConfigBase, +} from '../../CollectorExporterBase'; +import { ReadableSpan } from '@opentelemetry/tracing'; +import { toCollectorExportTraceServiceRequest } from '../../transform'; +import * as collectorTypes from '../../types'; + +export interface CollectorExporterConfig extends CollectorExporterConfigBase {} + +/** + * Collector Exporter for Web + */ +export class CollectorExporter extends CollectorExporterBase< + CollectorExporterConfig +> { + onInit(): void { + window.addEventListener('unload', this.shutdown); + } + + onShutdown(): void { + window.removeEventListener('unload', this.shutdown); + } + + sendSpans( + spans: ReadableSpan[], + onSuccess: () => void, + onError: (error: collectorTypes.CollectorExporterError) => void + ) { + const exportTraceServiceRequest = toCollectorExportTraceServiceRequest( + spans, + this + ); + + const body = JSON.stringify(exportTraceServiceRequest); + + if (typeof navigator.sendBeacon === 'function') { + this._sendSpansWithBeacon(body, onSuccess, onError); + } else { + this._sendSpansWithXhr(body, onSuccess, onError); + } + } + + /** + * send spans using browser navigator.sendBeacon + * @param body + * @param onSuccess + * @param onError + */ + private _sendSpansWithBeacon( + body: string, + onSuccess: () => void, + onError: (error: collectorTypes.CollectorExporterError) => void + ) { + if (navigator.sendBeacon(this.url, body)) { + this.logger.debug('sendBeacon - can send', body); + onSuccess(); + } else { + this.logger.error('sendBeacon - cannot send', body); + onError({}); + } + } + + /** + * function to send spans using browser XMLHttpRequest + * used when navigator.sendBeacon is not available + * @param body + * @param onSuccess + * @param onError + */ + private _sendSpansWithXhr( + body: string, + onSuccess: () => void, + onError: (error: collectorTypes.CollectorExporterError) => void + ) { + const xhr = new XMLHttpRequest(); + xhr.open('POST', this.url); + xhr.setRequestHeader(collectorTypes.OT_REQUEST_HEADER, '1'); + xhr.setRequestHeader('Accept', 'application/json'); + xhr.setRequestHeader('Content-Type', 'application/json'); + xhr.send(body); + + xhr.onreadystatechange = () => { + if (xhr.readyState === XMLHttpRequest.DONE) { + if (xhr.status >= 200 && xhr.status <= 299) { + this.logger.debug('xhr success', body); + onSuccess(); + } else { + this.logger.error('body', body); + this.logger.error('xhr error', xhr); + onError({ + code: xhr.status, + message: xhr.responseText, + }); + } + } + }; + } +} diff --git a/packages/opentelemetry-exporter-collector/src/platform/browser/index.ts b/packages/opentelemetry-exporter-collector/src/platform/browser/index.ts index e2ba0ac5a4..df00fee615 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/browser/index.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/browser/index.ts @@ -14,4 +14,4 @@ * limitations under the License. */ -export * from './sendSpans'; +export * from './CollectorExporter'; diff --git a/packages/opentelemetry-exporter-collector/src/platform/browser/sendSpans.ts b/packages/opentelemetry-exporter-collector/src/platform/browser/sendSpans.ts deleted file mode 100644 index a718cf17d4..0000000000 --- a/packages/opentelemetry-exporter-collector/src/platform/browser/sendSpans.ts +++ /dev/null @@ -1,141 +0,0 @@ -/*! - * Copyright 2020, 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 { Logger } from '@opentelemetry/api'; -import { ReadableSpan } from '@opentelemetry/tracing'; -import { CollectorExporter } from '../../CollectorExporter'; -import { toCollectorExportTraceServiceRequest } from '../../transform'; -import * as collectorTypes from '../../types'; - -/** - * function that is called once when {@link ExporterCollector} is initialised - * @param collectorExporter CollectorExporter {@link ExporterCollector} - */ -export function onInit(collectorExporter: CollectorExporter) { - window.addEventListener('unload', collectorExporter.shutdown); -} - -/** - * function to be called once when {@link ExporterCollector} is shutdown - * @param collectorExporter CollectorExporter {@link ExporterCollector} - */ -export function onShutdown(collectorExporter: CollectorExporter) { - window.removeEventListener('unload', collectorExporter.shutdown); -} - -/** - * function to send spans to the [opentelemetry collector]{@link https://github.com/open-telemetry/opentelemetry-collector} - * using the standard http/https node module - * @param spans - * @param onSuccess - * @param onError - * @param collectorExporter - */ -export function sendSpans( - spans: ReadableSpan[], - onSuccess: () => void, - onError: (error: collectorTypes.CollectorExporterError) => void, - collectorExporter: CollectorExporter -) { - const exportTraceServiceRequest = toCollectorExportTraceServiceRequest( - spans, - collectorExporter - ); - - const body = JSON.stringify(exportTraceServiceRequest); - - if (typeof navigator.sendBeacon === 'function') { - sendSpansWithBeacon( - body, - onSuccess, - onError, - collectorExporter.logger, - collectorExporter.url - ); - } else { - sendSpansWithXhr( - body, - onSuccess, - onError, - collectorExporter.logger, - collectorExporter.url - ); - } -} - -/** - * function to send spans using browser navigator.sendBeacon - * @param body - * @param onSuccess - * @param onError - * @param logger - * @param collectorUrl - */ -function sendSpansWithBeacon( - body: string, - onSuccess: () => void, - onError: (error: collectorTypes.CollectorExporterError) => void, - logger: Logger, - collectorUrl: string -) { - if (navigator.sendBeacon(collectorUrl, body)) { - logger.debug('sendBeacon - can send', body); - onSuccess(); - } else { - logger.error('sendBeacon - cannot send', body); - onError({}); - } -} - -/** - * function to send spans using browser XMLHttpRequest - * used when navigator.sendBeacon is not available - * @param body - * @param onSuccess - * @param onError - * @param logger - * @param collectorUrl - */ -function sendSpansWithXhr( - body: string, - onSuccess: () => void, - onError: (error: collectorTypes.CollectorExporterError) => void, - logger: Logger, - collectorUrl: string -) { - const xhr = new XMLHttpRequest(); - xhr.open('POST', collectorUrl); - xhr.setRequestHeader(collectorTypes.OT_REQUEST_HEADER, '1'); - xhr.setRequestHeader('Accept', 'application/json'); - xhr.setRequestHeader('Content-Type', 'application/json'); - xhr.send(body); - - xhr.onreadystatechange = () => { - if (xhr.readyState === XMLHttpRequest.DONE) { - if (xhr.status >= 200 && xhr.status <= 299) { - logger.debug('xhr success', body); - onSuccess(); - } else { - logger.error('body', body); - logger.error('xhr error', xhr); - onError({ - code: xhr.status, - message: xhr.responseText, - }); - } - } - }; -} diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/CollectorExporter.ts b/packages/opentelemetry-exporter-collector/src/platform/node/CollectorExporter.ts new file mode 100644 index 0000000000..639d373685 --- /dev/null +++ b/packages/opentelemetry-exporter-collector/src/platform/node/CollectorExporter.ts @@ -0,0 +1,138 @@ +/*! + * Copyright 2019, 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 * as grpc from 'grpc'; +import * as path from 'path'; +import * as collectorTypes from '../../types'; + +import { ReadableSpan } from '@opentelemetry/tracing'; +import { + CollectorExporterBase, + CollectorExporterConfigBase, +} from '../../CollectorExporterBase'; +import { CollectorExporterError } from '../../types'; +import { toCollectorExportTraceServiceRequest } from '../../transform'; +import { GRPCQueueItem, TraceServiceClient } from './types'; +import { removeProtocol } from './util'; + +/** + * Collector Exporter Config for Node + */ +export interface CollectorExporterConfig extends CollectorExporterConfigBase { + credentials?: grpc.ChannelCredentials; +} + +/** + * Collector Exporter for Node + */ +export class CollectorExporter extends CollectorExporterBase< + CollectorExporterConfig +> { + isShutDown: boolean = false; + traceServiceClient?: TraceServiceClient = undefined; + grpcSpansQueue: GRPCQueueItem[] = []; + + /** + * @param config + */ + constructor(config: CollectorExporterConfig = {}) { + super(config); + } + + onShutdown(): void { + this.isShutDown = true; + if (this.traceServiceClient) { + this.traceServiceClient.close(); + } + } + + onInit(config: CollectorExporterConfig): void { + this.isShutDown = false; + this.grpcSpansQueue = []; + const serverAddress = removeProtocol(this.url); + const credentials: grpc.ChannelCredentials = + config.credentials || grpc.credentials.createInsecure(); + + const traceServiceProtoPath = + 'opentelemetry/proto/collector/trace/v1/trace_service.proto'; + const includeDirs = [path.resolve(__dirname, 'protos')]; + + protoLoader + .load(traceServiceProtoPath, { + keepCase: false, + longs: String, + enums: String, + defaults: true, + oneofs: true, + includeDirs, + }) + .then(packageDefinition => { + const packageObject: any = grpc.loadPackageDefinition( + packageDefinition + ); + this.traceServiceClient = new packageObject.opentelemetry.proto.collector.trace.v1.TraceService( + serverAddress, + credentials + ); + if (this.grpcSpansQueue.length > 0) { + const queue = this.grpcSpansQueue.splice(0); + queue.forEach((item: GRPCQueueItem) => { + this.sendSpans(item.spans, item.onSuccess, item.onError); + }); + } + }); + } + + sendSpans( + spans: ReadableSpan[], + onSuccess: () => void, + onError: (error: CollectorExporterError) => void + ): void { + if (this.isShutDown) { + return; + } + if (this.traceServiceClient) { + const exportTraceServiceRequest = toCollectorExportTraceServiceRequest( + spans, + this + ); + + this.traceServiceClient.export( + exportTraceServiceRequest, + ( + err: collectorTypes.opentelemetryProto.collector.trace.v1.ExportTraceServiceError + ) => { + if (err) { + this.logger.error( + 'exportTraceServiceRequest', + exportTraceServiceRequest + ); + onError(err); + } else { + onSuccess(); + } + } + ); + } else { + this.grpcSpansQueue.push({ + spans, + onSuccess, + onError, + }); + } + } +} diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/index.ts b/packages/opentelemetry-exporter-collector/src/platform/node/index.ts index e2ba0ac5a4..df00fee615 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/index.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/index.ts @@ -14,4 +14,4 @@ * limitations under the License. */ -export * from './sendSpans'; +export * from './CollectorExporter'; diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/sendSpans.ts b/packages/opentelemetry-exporter-collector/src/platform/node/sendSpans.ts deleted file mode 100644 index 5b7c9035b7..0000000000 --- a/packages/opentelemetry-exporter-collector/src/platform/node/sendSpans.ts +++ /dev/null @@ -1,145 +0,0 @@ -/*! - * Copyright 2019, 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 { ReadableSpan } from '@opentelemetry/tracing'; -import * as grpc from 'grpc'; -import * as path from 'path'; - -import { CollectorExporter } from '../../CollectorExporter'; -import * as collectorTypes from '../../types'; -import { toCollectorExportTraceServiceRequest } from '../../transform'; -import { CollectorData, GRPCQueueItem } from './types'; -import { removeProtocol } from './util'; - -const traceServiceClients: WeakMap< - CollectorExporter, - CollectorData -> = new WeakMap(); - -/** - * function that is called once when {@link ExporterCollector} is initialised - * @param collectorExporter CollectorExporter {@link ExporterCollector} - */ -export function onInit(collectorExporter: CollectorExporter) { - traceServiceClients.set(collectorExporter, { - isShutDown: false, - grpcSpansQueue: [], - }); - const serverAddress = removeProtocol(collectorExporter.url); - const credentials: grpc.ChannelCredentials = grpc.credentials.createInsecure(); - - const traceServiceProtoPath = - 'opentelemetry/proto/collector/trace/v1/trace_service.proto'; - const includeDirs = [path.resolve(__dirname, 'protos')]; - - protoLoader - .load(traceServiceProtoPath, { - keepCase: false, - longs: String, - enums: String, - defaults: true, - oneofs: true, - includeDirs, - }) - .then(packageDefinition => { - const packageObject: any = grpc.loadPackageDefinition(packageDefinition); - const exporter = traceServiceClients.get(collectorExporter); - if (!exporter) { - return; - } - exporter.traceServiceClient = new packageObject.opentelemetry.proto.collector.trace.v1.TraceService( - serverAddress, - credentials - ); - if (exporter.grpcSpansQueue.length > 0) { - const queue = exporter.grpcSpansQueue.splice(0); - queue.forEach((item: GRPCQueueItem) => { - sendSpans( - item.spans, - item.onSuccess, - item.onError, - collectorExporter - ); - }); - } - }); -} - -/** - * function to be called once when {@link ExporterCollector} is shutdown - * @param collectorExporter CollectorExporter {@link ExporterCollector} - */ -export function onShutdown(collectorExporter: CollectorExporter) { - const exporter = traceServiceClients.get(collectorExporter); - if (!exporter) { - return; - } - exporter.isShutDown = true; - - if (exporter.traceServiceClient) { - exporter.traceServiceClient.close(); - } -} - -/** - * function to send spans to the [opentelemetry collector]{@link https://github.com/open-telemetry/opentelemetry-collector} - * using the standard http/https node module - * @param spans - * @param onSuccess - * @param onError - * @param collectorExporter - */ -export function sendSpans( - spans: ReadableSpan[], - onSuccess: () => void, - onError: (error: collectorTypes.CollectorExporterError) => void, - collectorExporter: CollectorExporter -) { - const exporter = traceServiceClients.get(collectorExporter); - if (!exporter || exporter.isShutDown) { - return; - } - if (exporter.traceServiceClient) { - const exportTraceServiceRequest = toCollectorExportTraceServiceRequest( - spans, - collectorExporter - ); - - exporter.traceServiceClient.export( - exportTraceServiceRequest, - ( - err: collectorTypes.opentelemetryProto.collector.trace.v1.ExportTraceServiceError - ) => { - if (err) { - collectorExporter.logger.error( - 'exportTraceServiceRequest', - exportTraceServiceRequest - ); - onError(err); - } else { - onSuccess(); - } - } - ); - } else { - exporter.grpcSpansQueue.push({ - spans, - onSuccess, - onError, - }); - } -} diff --git a/packages/opentelemetry-exporter-collector/src/platform/node/types.ts b/packages/opentelemetry-exporter-collector/src/platform/node/types.ts index 8a7786038a..b36b9a65ad 100644 --- a/packages/opentelemetry-exporter-collector/src/platform/node/types.ts +++ b/packages/opentelemetry-exporter-collector/src/platform/node/types.ts @@ -34,12 +34,3 @@ export interface GRPCQueueItem { export interface TraceServiceClient extends grpc.Client { export: (request: any, callback: Function) => {}; } - -/** - * Interface to store helper information - */ -export interface CollectorData { - traceServiceClient?: TraceServiceClient; - isShutDown: boolean; - grpcSpansQueue: GRPCQueueItem[]; -} diff --git a/packages/opentelemetry-exporter-collector/src/transform.ts b/packages/opentelemetry-exporter-collector/src/transform.ts index 3f67635ce6..4078a3ea60 100644 --- a/packages/opentelemetry-exporter-collector/src/transform.ts +++ b/packages/opentelemetry-exporter-collector/src/transform.ts @@ -24,7 +24,10 @@ import { import * as core from '@opentelemetry/core'; import { Resource } from '@opentelemetry/resources'; import { ReadableSpan } from '@opentelemetry/tracing'; -import { CollectorExporter } from './CollectorExporter'; +import { + CollectorExporterBase, + CollectorExporterConfigBase, +} from './CollectorExporterBase'; import { COLLETOR_SPAN_KIND_MAPPING, opentelemetryProto } from './types'; import ValueType = opentelemetryProto.common.v1.ValueType; @@ -189,12 +192,14 @@ export function toCollectorTraceState( /** * Prepares trace service request to be sent to collector * @param spans spans - * @param collectorExporter + * @param collectorExporterBase * @param [name] Instrumentation Library Name */ -export function toCollectorExportTraceServiceRequest( +export function toCollectorExportTraceServiceRequest< + T extends CollectorExporterConfigBase +>( spans: ReadableSpan[], - collectorExporter: CollectorExporter, + collectorExporterBase: CollectorExporterBase, name: string = '' ): opentelemetryProto.collector.trace.v1.ExportTraceServiceRequest { const spansToBeSent: opentelemetryProto.trace.v1.Span[] = spans.map(span => @@ -205,9 +210,9 @@ export function toCollectorExportTraceServiceRequest( const additionalAttributes = Object.assign( {}, - collectorExporter.attributes || {}, + collectorExporterBase.attributes || {}, { - 'service.name': collectorExporter.serviceName, + 'service.name': collectorExporterBase.serviceName, } ); const protoResource: opentelemetryProto.resource.v1.Resource = toCollectorResource( diff --git a/packages/opentelemetry-exporter-collector/test/browser/CollectorExporter.test.ts b/packages/opentelemetry-exporter-collector/test/browser/CollectorExporter.test.ts index d17551c866..f8e5decc0d 100644 --- a/packages/opentelemetry-exporter-collector/test/browser/CollectorExporter.test.ts +++ b/packages/opentelemetry-exporter-collector/test/browser/CollectorExporter.test.ts @@ -21,7 +21,7 @@ import * as sinon from 'sinon'; import { CollectorExporter, CollectorExporterConfig, -} from '../../src/CollectorExporter'; +} from '../../src/platform/browser/index'; import * as collectorTypes from '../../src/types'; import { diff --git a/packages/opentelemetry-exporter-collector/test/certs/ca.crt b/packages/opentelemetry-exporter-collector/test/certs/ca.crt new file mode 100644 index 0000000000..455c498aa2 --- /dev/null +++ b/packages/opentelemetry-exporter-collector/test/certs/ca.crt @@ -0,0 +1,31 @@ +-----BEGIN CERTIFICATE----- +MIIFPjCCAyYCCQDSzsM0Ou9GwDANBgkqhkiG9w0BAQsFADBhMQswCQYDVQQGEwJD +TDELMAkGA1UECAwCUk0xGjAYBgNVBAcMEU9wZW5UZWxlbWV0cnlUZXN0MQ0wCwYD +VQQKDARSb290MQ0wCwYDVQQLDARUZXN0MQswCQYDVQQDDAJjYTAeFw0yMDA1MTUx +NTQ0MzVaFw0yMTA1MTUxNTQ0MzVaMGExCzAJBgNVBAYTAkNMMQswCQYDVQQIDAJS +TTEaMBgGA1UEBwwRT3BlblRlbGVtZXRyeVRlc3QxDTALBgNVBAoMBFJvb3QxDTAL +BgNVBAsMBFRlc3QxCzAJBgNVBAMMAmNhMIICIjANBgkqhkiG9w0BAQEFAAOCAg8A +MIICCgKCAgEAs1AVbpZ642HATrkqW0WpzsOAne677zDftkvIhWcto3x+nwP6kSOE +vHtPR7xem9Yl5LUy1aDpd0WnBSke1JIYdJCAmmlitFVShrpolGRb9MqYJPXp5FfH +OFltziG00/MSKwNv7GiwN3ehyvzfS9L46mCcUWnQLJkjkThvlV0JRCfaTBRF3m8M +fKYvQ71G/9ZwbRvRqPCk8CZmzhqKLvRFBmzM2FGj0CY5fFqPcBRM08MWNkxAR/4B +IGKTaz5qzaFEvxHgQMQaXOQZYeNwiCFBoGygOId96x8GX9AT1PwW2ltMU3rNtVCf +9xu3JUREHjkIReNqM9h1qq5YIfrEQYeM1Q5Kyr3+Bpj6EhZqGmfc37z/nootxG3z +VmYZ4+z0zx24s117J7CfD2OLL2OaLyWheXXYqB0gOgoTwwwTsB5DYOv15fjsqs3F +kuYR/hbxs1GQO9RcOmlvynIleiVkm1x+UmOuIltfMjolBPc7ZKKxjlAxbC4oY7Za +3th3UkDIVFJmWsJhj+z87qLq0EW4m5UYV3uIUDN4P6Pko3iTqKG2qUtnnhrlbvhd +/YfSCWJRMSlgCfKFuhGkiVDEpJhza5LxNeM2EYD/PIydotyASw2Btp+VowC6yDJV +yR2cTVEGeYxQXpOI0wqJT8DrhWsdAqioLtaFxNJkdTKWAbfC8MP5wp8CAwEAATAN +BgkqhkiG9w0BAQsFAAOCAgEAP7u8IlEOTBrL3OISH9vUqFbiRdTzPfpFJ2ZVxM3H +C4iLdndKVmJLRJyMeGhD/kEnTMmHrt/mZTw6tI87+PE1ZMqSe4+q2NlHz0BouiQa +ukGj+OzZ4gw+IlDfyiXtsggCb1dRZldGoddiP8ldP0ohvR7nErG0RrRuBp860yPD +qBzItTzpC4dNVBbOBf+m9T914dsznFKlyU+QSVA2TXpJnmfEKCwlyk2gVH9olQlG +ND4cBdnOnarV5eflIj+LXjZh2wt/F0qLpTmUmxEyCc1M1il+hC6hnbarzin+8Cxu +VqjKzG7KcLxlWx9wj6ruBA1kPL0Jx31c8wDJ8b7HtsDzehcwrKKnZwA3qs3r417c +n7Dddbix9Gxxi2MTY83Q3MKbVj+oKxz0wZxa29fvlf3Gv98wzSMcS2cK+bjQwwuJ +WQxH9KksKU6g1Dv3fVz2E5CP9gwHaQBVBNSKxlqQsB2nhNglpigmglCKrfX07c7x +ryzoDE1E7tYguyWa4W+LFJ85EirUkGIBL7IoGCsol/elF6noGiuaNMO3KsWmp/C6 +YsXQJPWrnep93CCZdZ7bY6L6BTPdz1RaXMh8Rc65MlIlTzxPnhFTYrXz/FlK2uv7 +lPvT0+cGOvuiN26vqfKnrid1I2theKhKDWSdv3Rshg0ZJatNWS0u8gTE4f+qCjHP +9CI= +-----END CERTIFICATE----- diff --git a/packages/opentelemetry-exporter-collector/test/certs/ca.key b/packages/opentelemetry-exporter-collector/test/certs/ca.key new file mode 100644 index 0000000000..e8b01e04ea --- /dev/null +++ b/packages/opentelemetry-exporter-collector/test/certs/ca.key @@ -0,0 +1,54 @@ +-----BEGIN RSA PRIVATE KEY----- +Proc-Type: 4,ENCRYPTED +DEK-Info: DES-EDE3-CBC,C088BF4BACFE1D5E + +TKzb0xd1SS8So+VGtAOqj7XhYJNaTSl7HrF5UXoL835lzU6qIdgJWp8REOATdYTP +wqL5x3OlRy/X9GUtXApQx4OoCy1hOMXB10/T1nD+EuxBf4ChEtRow1synEfOVlX8 +JZvRHuvN1AGnOzn8YpCnZ19ufw9ASX1cOFjefJKiR8vi32/LEO5No2jqODTWK3V2 +ijiV01hDkbiWvIoxcLQRXm+F2TAZ7MYz/DEjtbAr+4vCDMobJicWHim6yHpor/B0 +7bBVEsR0/R7kb+fLtv9cBDUqu40m7LfuMFtJDD5deRce2hSs+rm9nO01qvo5KvR5 +XA9WdKdFjk3WKjE0uAhRCzXXvRO1S9i6Ym0E3zoW6zcXItQUo30BhBgn4DALMMw/ +aLAsq0trmXqTiJCq8QDYgQOj59jwVxMuAsvinhqBI8koy92hBiXAhZd0r2+2jm/b +yqELuX+0b+FW0hSRL/BsXaTXrzW9cSpSM+EsCtoZloNecGGKNUIhVF6+LmALQ5xD +5dwIIooQTpNzLpc55rK6C01VWQLRWClJdbASdYD5hmY/0KNq/LB7F4TY9DjnJnWx +Lrkalyl8lv1oZHjPUqA8NAY+Rf+Ps6BxxP2ShAfVwybVFh0ACh5stWpAbmWId86p +vnf4gW2y5g4p9HNK/+XuFJ4PQj4/SJNRrc7HvwlCnAg1lXRYtt2C2awbKPzBU7bw +4sqOKlIOSeox6x3APcO+nTuYZf2XJ9s/jtlPqPgGBaaWB6IANiMBwi2LnVCjxaL5 +tjiBQlwcYSla7YPz7AAuRYcv2zPJVSk8pZqObBZO+1JN/BJf0LUqW4fOKSwud8gG +rDHp5YS/+MOnygvuyooqdFoFwS6/fKzdLKz5Ug0ZsIPEVdd0gQUrNReATptmRuxJ +/dA58RLpsosCz2iMkYxEJ75acmPsZU6DZCHrI/WwDR6xOVN+3YttpEoGXa16D7Hk +Pa+tmObX3aK+iAQBoSsiztxaBYRNc+QbpKl1/qU86+2m8yXnsbKDXk3WnFVMBCw2 +VbdgD7Rx72sYhzn2VPGmoRkOn/yOkhful7R/tNTK040FuBQaFWer5yDsUlWIoYgd +wnTdSdXisib4rfq/t50xfCGS67eyaH/CMbAni/x+eikDFAA3/OLMM+46hZaoZHqP +sOcbcD+JUIwo00xW2Xv2gF8NT4mcdVphRs9u1pcoyZCQm4OuE4qfJhYH2k48imCC +yfQVgr/fitMm9/oNcEkCuGI5iNm0f88dIKZSuAaxBQ9AXxRjgGVxjdasTcFwkMMo +ahgasfOXq53HoPgX7UOB9V4DdtzwwUg2cS3G0aC8Z2botQ7JlA87QvHddLPrFE3r +ybHIgxOOhabCNpO0ER0xaaS6dKhq/oEuh4owPm7fnfx6lYVmxELJoyuGvGJjlDjk +Zks4Du6Ew6KuZRbGJQOod+FAT1uCIOt83Vslp+3rURe9NmUmU6xHSOnb3La3pLco +upb7x8ufsE8y143uyiqDAyF7MluCl/Cc0rO7BPOu/QsXUcm+oE/b+WLCfDkWETHp +6UK6bW9gi3iohm1S5ViLLSQGcXF62rkP0PQMZpxemQdsKJaynjUmtY13h65L8GRh +4Btxb3/fZgsBDT8us5SP1qSNFsygJwKuRGLaGqrbx+o/deA7kSwX/UFrAemAkysE +1WuFvGlrhTUXcYmjKGbP+78IyPuhcG+lxp1QZXpdIv9Bos2m475we1gSAi2qOF02 +2op60zNo8ZsBRSI/QKtojfG+0SlCNO7owzu+j6PH+7rHpSL1DaPK9C1xwxQCsRaO +MIU+ELIWboJK3lNChQ11mnyMjoIMsfR9fP7Cmr4FuvCHYQbCFERLOzJ6FU7974+b +ul6VAsbvsutLRziQ3LN+QdQRsrrvq9YU0CgB8jLUHf137x4Goegb3cxlDjwzpGkt +R3HM1KAbxcbyziQz2NuSZK5Jfg/OO+C6o5HN2j3IfhQyM1PZ7MsO6sEaRWBxgC99 +xjXYUyDRt2Ho1mFmRtdXjmeGExz3QBQ7X66swHwMcBov6uL9x060VXfzFB6Gbn6O +2UabP4eriWuGUSk/fVBg3jqe+iMMM4z++mScmCqWUnp6lzUSzhsCyZ6a/11zsyvF +Lq8GDu+4rCFzj8/jgE3rqPHGPM7cgn8kv7IC1cOMDMWmELPZW38bxbPYPbNiNgtv +Cq0OjCCSyB307gC2VjwbXyN7AAT0mul7BhQOxU/qIqRoGKUGuQLWIp42Fe0TAe8x +Im1baX8SV35KagGLvcBlw1uwA6olzo4WyxH2SyVEfYxBqek7DmZ8LUwH7s+Xs2+M +svr++dv3drLOdz75Wj7N6KiK0KDxv5EHLiP3YD8/UqP3GzMDv+yj3lpVOcE40kEo +HWhlv7X7fZWUCV9iiRSKWzYBhps0LWjJ4ryB/5wU5X/iSTLyP9cYPKiQIFyaWDK6 +POcYrgNN62e32PScENlwy+YuL4xuaa3KnOTS4e4emjzdH576y213D+n7bpFVOvi0 +JEm8qJJ7PgrwnuGcnNjIfIJNDrLqXDYJWn0K59Pjfd0i3VRhOiNFzcIRnNePR//h +lwBlhy0+XpUvxNEt9Ju+xaaSxg16cyKlz6lz8P+4TGuw8cgXdSXcZw6w+RDdmiv/ +NkVUPEwtMh3+H6L4Lfy9h0HA0bnpnOdgbfeTbHHv5/ViJd7cAjF4Z7PTEpC8nT++ +RTqp4q1upJjb5vk2IkrvhPAO/ZjK01ijSx/sieYoSxp2+vme/4yYloD3IjoUR3SB +0DOv5ATQUNABKAOkZkkpeA0IRuPdbLqpd4FQLYi08oJbOEiVkCUzmBwxbvCAkN83 +KCey8TP/OXVg9+lsh5UgaVPNZmNWGabHIsAnp4TszQZWsxAywOvBSWAb+Z8GOCTP +8T24RYphijZALkXzssYeCZ6qOl/V6YKa7dkIrWAyVRsZKQYH73HzJr7qR0N84eXu +4yyi8rb31d/6Gl+ZyvvDMeQBOFlKtHRx01VG/jLlq2qBuv4lY+UFFDpV2l7F4rVV +IwAuU/pYcuJ97bocLvrdCZJIdszlNgGHpKcBn4MWT+lcod/iBsloXy6J6kluaXBu +q8Ub9zwiF/aKM29CcBRnIHMIVSZ5FY9/Zbu8EhnZjTe7NUNNWi9uV0Arht5S/3RS +-----END RSA PRIVATE KEY----- diff --git a/packages/opentelemetry-exporter-collector/test/certs/client.crt b/packages/opentelemetry-exporter-collector/test/certs/client.crt new file mode 100644 index 0000000000..9534695d80 --- /dev/null +++ b/packages/opentelemetry-exporter-collector/test/certs/client.crt @@ -0,0 +1,31 @@ +-----BEGIN CERTIFICATE----- +MIIFPzCCAycCAQEwDQYJKoZIhvcNAQEFBQAwYTELMAkGA1UEBhMCQ0wxCzAJBgNV +BAgMAlJNMRowGAYDVQQHDBFPcGVuVGVsZW1ldHJ5VGVzdDENMAsGA1UECgwEUm9v +dDENMAsGA1UECwwEVGVzdDELMAkGA1UEAwwCY2EwHhcNMjAwNTE1MTU0NDM3WhcN +MjEwNTE1MTU0NDM3WjBqMQswCQYDVQQGEwJDTDELMAkGA1UECAwCUk0xGjAYBgNV +BAcMEU9wZW5UZWxlbWV0cnlUZXN0MQ0wCwYDVQQKDARUZXN0MQ8wDQYDVQQLDAZD +bGllbnQxEjAQBgNVBAMMCWxvY2FsaG9zdDCCAiIwDQYJKoZIhvcNAQEBBQADggIP +ADCCAgoCggIBAMm4t0aiZqouBsW/VilH/McgrMECz6RYMnAxAZVG0AwvlzZPMc46 +Vpbggpsn5j/N/teragpiqIwIIN+1apGXGmAg4IDgyrswq37Oj4JrvmzXWK1PGGFs +YpWISmNR1DKkEL8ts41KDEZejsItFYctnvIctRYPoYB+6No2iddj5gioHyq/yDLN +zD0c0C3r9tXm+Ed9BO4pgu6Rl6zuPf3sttE5eNa/O6qV1dD3nxnpPS3fIbXqKviD ++xhgXrfLM43X0QBQt6sPFuunpcvhWDsgtWMQ6EShQUhb0DXr6PgGXj/1Vl3nVsxP +4gnCOE5x13jzw/tqijbKin2+dpEGdi+c0QeVfDWoMZA9mlitZiLsenKdB8sYaoCw +QZHu3zzfXruMqA6x6DyLPa6PEFzw4v5PAvsd4Re0cLTBDsw1Fdx/eGzBg7k1KCFZ +HA3RdzNqCMvxcumH7hUg1n0cEtHX/bVSdpndK7iWVPbDYv98bFNOq8fZzsoqZgOk +Jl4TJyil/oPDkzowc8F8+p4vWdgHevjkqk5rtyMLBb6KnUmJgYPef7FuZ97oSi+r +TrAUs595+RZefDRdu5MGV/2NMbpN992Yewg7LTiP+gwNuYBDQmEYyQf0sxMNcwXc +ZVrWw+RdI8udSFowmOd/g0NNz3CaAXX8n6BLMJBBxRx0zet/88VFtLNrAgMBAAEw +DQYJKoZIhvcNAQEFBQADggIBADfQTBf/n+r+E6/GH3kyiI4jg0vIlkOlABsypKvY +iPXGTrtTlFB4s18/f0I416ez1U129OYyE2mUHKDKAUHu/Qf3Cl5N983DCx7czVJZ +Maxafe7DS5rAwF1wpfxR6u4Ti0gK0HO29bsCDah5C5+s4Vzv5t6AFmyg+ESQG6cM +vbkIs5nbcU1ydMdfvSb3vmjvPLh41lWnRVkkbjgzTS312EnHmqV3wIx12UAb16J4 +zXOjI+7JU9TZRnTEf3xOyByA5h8pCYha3nOlETR+vRN1byUYesCWsgj0wFU1u6K6 +AqSMU4sqtNIIlwN50CPLvYjB3FBPh8DpB5iQ4GxM636X06dQqQF7n4cWMOMHRlT1 +DgafEpVdxSeJMzuBQHJzF0UbyaAwKkDKGuAZWfihlNEUMdVm4EvKpE82cevM/2Mo +VEuPlcmf+D0ERu6bK5RAjXkH+cxYWXJGRtx823IEEgXOk0F4AMCaMiuNHI7buBi7 +AnBvIUv67b6FRS6Hw8sMDNvVTpavsnUKwSJJUATPU+rRIgD3Dl7SJ9XqmFdgPO+E +eRxvCCZvzEL77SLslv6CkKLseNQQ7MrOgTotYOrHA/AwF1GtFSDoYTRifKGynRPO +Vg3CscBOkIz9Plmy6dq8CEIygdmcN2Bb8BwA97q1epU4vzmx7fhqLLyMq+YztPRp +6SLz +-----END CERTIFICATE----- diff --git a/packages/opentelemetry-exporter-collector/test/certs/client.csr b/packages/opentelemetry-exporter-collector/test/certs/client.csr new file mode 100644 index 0000000000..2c7d0f9c04 --- /dev/null +++ b/packages/opentelemetry-exporter-collector/test/certs/client.csr @@ -0,0 +1,28 @@ +-----BEGIN CERTIFICATE REQUEST----- +MIIErzCCApcCAQAwajELMAkGA1UEBhMCQ0wxCzAJBgNVBAgMAlJNMRowGAYDVQQH +DBFPcGVuVGVsZW1ldHJ5VGVzdDENMAsGA1UECgwEVGVzdDEPMA0GA1UECwwGQ2xp +ZW50MRIwEAYDVQQDDAlsb2NhbGhvc3QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAw +ggIKAoICAQDJuLdGomaqLgbFv1YpR/zHIKzBAs+kWDJwMQGVRtAML5c2TzHOOlaW +4IKbJ+Y/zf7Xq2oKYqiMCCDftWqRlxpgIOCA4Mq7MKt+zo+Ca75s11itTxhhbGKV +iEpjUdQypBC/LbONSgxGXo7CLRWHLZ7yHLUWD6GAfujaNonXY+YIqB8qv8gyzcw9 +HNAt6/bV5vhHfQTuKYLukZes7j397LbROXjWvzuqldXQ958Z6T0t3yG16ir4g/sY +YF63yzON19EAULerDxbrp6XL4Vg7ILVjEOhEoUFIW9A16+j4Bl4/9VZd51bMT+IJ +wjhOcdd488P7aoo2yop9vnaRBnYvnNEHlXw1qDGQPZpYrWYi7HpynQfLGGqAsEGR +7t883167jKgOseg8iz2ujxBc8OL+TwL7HeEXtHC0wQ7MNRXcf3hswYO5NSghWRwN +0XczagjL8XLph+4VINZ9HBLR1/21UnaZ3Su4llT2w2L/fGxTTqvH2c7KKmYDpCZe +Eycopf6Dw5M6MHPBfPqeL1nYB3r45KpOa7cjCwW+ip1JiYGD3n+xbmfe6Eovq06w +FLOfefkWXnw0XbuTBlf9jTG6TffdmHsIOy04j/oMDbmAQ0JhGMkH9LMTDXMF3GVa +1sPkXSPLnUhaMJjnf4NDTc9wmgF1/J+gSzCQQcUcdM3rf/PFRbSzawIDAQABoAAw +DQYJKoZIhvcNAQELBQADggIBAFjedQr52vLv7YxeLxIvyHrMhbx7Iz4ztj3NlnOJ +EMGm7pcum/rGol1z8m7Y3mFbfJJp8IY/jn1w92x+M9pc6zsRo9MsKdqEAKhAjwVh +jYNBWHekrcwGIy6YUSFvZeUZ82IxFcf6N70CH4sLUJLbZXcd5Nui8mZJCPC4SLoC +E51P0vUClnS/l4O+Dz/IfBy9cSvGg3YvF8GGmW7IZdTD4bWg9O8lQi0zcnDGR0Er +N1Tegoe38Mrx49IHpWMEQzJhI6R22CQ0wtk6e8oBuz2No8hnY0yrAvBGI9v8GUE3 +FJAQxHzyUXCA50IcHFruevsgEzixmYb8OfDd1LC3nZJHfq2r5j0jOU6XXxukH8R3 +UyGIf8UpJQqBKHe0Ld0tOWSyByiWHvw4/Nir/DhANezIEsq4A0Y9hq6y2GTtFUnx +HdsYqTmVlrghBiqZF2H9f7YWaRBnsbu6Kkpyc55r8pBZMT2Myu2Gjq/8GAWtEy1J +BYmQfIZUnYksFaZiXvSiyfNaX5M7nvddxkBCyhtwtCzVutL+ZoqwXD2PPaUCuBbu +lu4M7iSjKiibiCqQEVyRPn2o8V4R5r0NmqS+B9CYJECeAnLPO49Z3l4wdJUEww9i +U14lM75e2tfFzaa/ZqOCQFuu84NKacTJUALpdg1aHcPtTG51F2U8EwsoZEBxUBb+ +WR7X +-----END CERTIFICATE REQUEST----- diff --git a/packages/opentelemetry-exporter-collector/test/certs/client.key b/packages/opentelemetry-exporter-collector/test/certs/client.key new file mode 100644 index 0000000000..e0fea66664 --- /dev/null +++ b/packages/opentelemetry-exporter-collector/test/certs/client.key @@ -0,0 +1,51 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIJKQIBAAKCAgEAybi3RqJmqi4Gxb9WKUf8xyCswQLPpFgycDEBlUbQDC+XNk8x +zjpWluCCmyfmP83+16tqCmKojAgg37VqkZcaYCDggODKuzCrfs6Pgmu+bNdYrU8Y +YWxilYhKY1HUMqQQvy2zjUoMRl6Owi0Vhy2e8hy1Fg+hgH7o2jaJ12PmCKgfKr/I +Ms3MPRzQLev21eb4R30E7imC7pGXrO49/ey20Tl41r87qpXV0PefGek9Ld8hteoq ++IP7GGBet8szjdfRAFC3qw8W66ely+FYOyC1YxDoRKFBSFvQNevo+AZeP/VWXedW +zE/iCcI4TnHXePPD+2qKNsqKfb52kQZ2L5zRB5V8NagxkD2aWK1mIux6cp0Hyxhq +gLBBke7fPN9eu4yoDrHoPIs9ro8QXPDi/k8C+x3hF7RwtMEOzDUV3H94bMGDuTUo +IVkcDdF3M2oIy/Fy6YfuFSDWfRwS0df9tVJ2md0ruJZU9sNi/3xsU06rx9nOyipm +A6QmXhMnKKX+g8OTOjBzwXz6ni9Z2Ad6+OSqTmu3IwsFvoqdSYmBg95/sW5n3uhK +L6tOsBSzn3n5Fl58NF27kwZX/Y0xuk333Zh7CDstOI/6DA25gENCYRjJB/SzEw1z +BdxlWtbD5F0jy51IWjCY53+DQ03PcJoBdfyfoEswkEHFHHTN63/zxUW0s2sCAwEA +AQKCAgEAjZvNlZl2RuuOt41teAdgLY4DmG9XwwBjUB0nBlsyvAtAtNB9n0+W783m +AfPNkGcVCuP7yhSeS8d9BG6/xDr2Oht6Xx7vUt+E1L0/Q4hNouy+BNQswl+rCVwn +FHgiZfaFByCXFo2v9kp1H1006rOdDEwY18bbUnBFGMMGmx03JEaZspH1gay1PwWW +I1at7lV5X/4k0uhzUPUGLFEHVdWyNUiKSv7ubP9InaznlPIGj8g/Swx7ZACK6f7l +H1NX+rBRuU3w0fYC2iXTnz+vh7qbe1MoKt2lDZ3emavl3Q/jZDTfj4ZSiZVekgk1 +K+SBJhjCMSIGqxYeiM2HQKHvn9cPaWtEH+B3zPSauURngPxhayLsVywrqAIqh2gI +iQXnqajwn/g6KF+eEYfdJyPUv0DZgS9e8I8jeGf6Dax4SYWEtl835+r7FsejXLXZ +ehYhIdjyG16+NpLcc5d7/xaSbu9cB7I64raQCnmVbSo/iixd3TwVgFsufRqSgL++ +xa33Y0n4Tq3HgIFg2vlX+6T0RGtWRw73gmk4SXc55wG2v5a2emhQEijfoLPHEQZw +6Xd7qHHJtzxAP+Ifp3IlQ6vW0S27SIiLmQoSZBd3So5r0iF5ufIWe6215EmCdQdt +y6t000Lc8wk/0p50nlaF3Gq4dVUwkXfse/Spb+cbu4t2hSGuC4kCggEBAOuZc3MP +8OZ7vuiCgkRsE+9vfouOxmUbeP0pQzDhG/havRG6J6PG5zltmZFqJh/JvFibnRhD +UZebL9+ugYbVqSPaijuW4MpP1RSZJprxKcwiXkvIXOmB4rDbrBT8OinN7KOXDG9D +6HpeLcRG38ayMfCPMCrNjHW1J/qwJHxycuLme76d7fevxGhojJE6tICasE9SVoF7 +lc+GK/tQKbjztF1QJHXgELSDRP+uHZx7G231HiOqomMIdI0F4fXJHWk2sYBJ33zn +1/c0hPhMks1eXQiod5jXfDtwoaaArkV7S7uahDpJmi2I0HNesWoMrUKeGEEJf9mR +qHSyHozsqqmyPwUCggEBANswSrFUc1oJfA39VTFwLW54VMhb7JuKM+2h6lrZTenK +m1IwZ3sNBub6mjDtPVBG/pvIYwAAfx1liOZgyKyDj0ticWF1sAfFnWKKN7OJTW7v +45Y8oFg10CHNKOWaJd0eAEhoFHW1kPMqrM6d6uYHf60ayQTkyloKkEakBiq7YkhK +ilExk1jyqiJFU/WFEvb6kL5yg1bn1NswaOebpvXSI0z8IzUoVfRXjXB0okOrgiEI +Cn3jOO2b1hF9PHVCYbiIJnoNIhP+DdEoTpCyQy8FwWXGvtgEdwfGm8PH0iH17ehY +D8ODb3NV3HyLzoORLnqHN6G7XF2N3Y2yL2jnLBpJU68CggEBAMp514lkgtFiOiDS +wKeTBtL4zBWeP4z3PlS8GH2yiPo46VKJ3LVZJLDrK1aYlmktVAwGuMz4Ve/oNA2V +iMXbbABfOfuaYFgeoe6Q7GeuqRBB3S5d5NPdh3gdYleqqUXyLtQs5UfeYbaAp+6O +RpUZ4edu96NhgbxLUy+UH9c/+NJd6K1aRwBd83sTlvLdM/Fuf+W7ypJ/JrHyCmxy +aVkFQNYNITiYt2Kbijn+Zn5sIpeuWBeo9uQLiTcFfjtge0FH+uZZFpPfIHDYlwpZ +rLSIy4W8WwRk9OSUmKhi4OLf4qc5VThOtw05DoSINgsBGAovmoKSamkOUGryBWVx +o/4xLQ0CggEAabWtoD5hb3/5g2m1R6WZU5jXEtY6k30gtC+Nrgj1aZacOBQ+I/tR +Y95itMwF8Qx8SLdo/5w9sfjBAJKW1ZSRbELq+Zzfq6/jyp1sZbsHTESHl3JfxosV +eOfQHIOuVSjd7A2+KFLLuGrRcsh4fD4Llnm/jwukh65mjJsYmk1LBiBk+umU7aYC +5YpYBqYKUnDfk+n4a9ZdMuTzAxhvekjBW6SSelWctr3u6dhmVYqGtNWC8dm/H+Ez +abXjjY3ZQTzwiZaB4/B3y3LMCT7f5fK5phMnAVmN6oMfplldf6Fy/sZRu/JMsuwq +7SokDBHdv5ws+WQ6FKiRvH++G7K582d/4wKCAQBb6GKm0GXD0Cj0S7jGCUtOzSKx +k35cWe3YUByFQ5cN5O1kRr4xBgQin7X0Xn2WY1xCMRocslpScfVgE2WJcbVaoiqI +V7dq4N1ZhkL9dWy25Q4vmnHZU6NEZMrIC6Upd9X7uhamLJWMEqUeitI43CtjB+hF +bnD66o3ne+5QjENKOcRtssv92gUnbAtRzuy9clq5aTk37cV9e1iHTPvnILeX6hzK +szMF6wpmfbn0uzwD6HMKdGFoocc3h/0iXtk1zFTIQt7BB/aCA0VYKToCb5flgFb2 +BoswTm+ui/s2fQYlMb864gIceJBOI4+zgNeKMSrKLfp42QD3DhMtWbfpvygY +-----END RSA PRIVATE KEY----- diff --git a/packages/opentelemetry-exporter-collector/test/certs/regenerate.sh b/packages/opentelemetry-exporter-collector/test/certs/regenerate.sh new file mode 100755 index 0000000000..bb6ec4a9b5 --- /dev/null +++ b/packages/opentelemetry-exporter-collector/test/certs/regenerate.sh @@ -0,0 +1,19 @@ +#! /bin/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 -passout pass:1111 -des3 -out ca.key 4096 +openssl req -passin pass:1111 -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 -passout pass:1111 -des3 -out server.key 4096 +openssl req -passin pass:1111 -new -key server.key -out server.csr -subj "/C=CL/ST=RM/L=OpenTelemetryTest/O=Test/OU=Server/CN=localhost" +openssl x509 -req -passin pass:1111 -days 365 -in server.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out server.crt +openssl rsa -passin pass:1111 -in server.key -out server.key +openssl genrsa -passout pass:1111 -des3 -out client.key 4096 +openssl req -passin pass:1111 -new -key client.key -out client.csr -subj "/C=CL/ST=RM/L=OpenTelemetryTest/O=Test/OU=Client/CN=localhost" +openssl x509 -passin pass:1111 -req -days 365 -in client.csr -CA ca.crt -CAkey ca.key -set_serial 01 -out client.crt +openssl rsa -passin pass:1111 -in client.key -out client.key diff --git a/packages/opentelemetry-exporter-collector/test/certs/server.crt b/packages/opentelemetry-exporter-collector/test/certs/server.crt new file mode 100644 index 0000000000..62f91722a9 --- /dev/null +++ b/packages/opentelemetry-exporter-collector/test/certs/server.crt @@ -0,0 +1,31 @@ +-----BEGIN CERTIFICATE----- +MIIFPzCCAycCAQEwDQYJKoZIhvcNAQEFBQAwYTELMAkGA1UEBhMCQ0wxCzAJBgNV +BAgMAlJNMRowGAYDVQQHDBFPcGVuVGVsZW1ldHJ5VGVzdDENMAsGA1UECgwEUm9v +dDENMAsGA1UECwwEVGVzdDELMAkGA1UEAwwCY2EwHhcNMjAwNTE1MTU0NDM2WhcN +MjEwNTE1MTU0NDM2WjBqMQswCQYDVQQGEwJDTDELMAkGA1UECAwCUk0xGjAYBgNV +BAcMEU9wZW5UZWxlbWV0cnlUZXN0MQ0wCwYDVQQKDARUZXN0MQ8wDQYDVQQLDAZT +ZXJ2ZXIxEjAQBgNVBAMMCWxvY2FsaG9zdDCCAiIwDQYJKoZIhvcNAQEBBQADggIP +ADCCAgoCggIBANQwHRfyj/d8Hh0qgDlxdtSxloRs8ZvBIwt6Accd1hUqs8dC0c9V +5XXOcfmusb3Fo8NKXn6IIPCEy1spFCe4EBW4obSgkJEVdPwsMsXUPLek/6K5S6uE +FhnGLUJJ57gAjh9LGdMTDp5szLO7dTYrHzdGZYhmTAyiA9JDN6iYlpWkK4p2IBcN +diu26KWp9+sJKw8Ly/7o5QD4wyc6hGok0v0nwimXZo78EJYBu6BDGuLyAgvq8zLV +sgXi4aYROsmVrg2IJbe8+PtPBNwkoAuR4QC3hRTV3bXyZdbIC0KbOekegAHTeXYz +Ap0HVkCsb/vOLiGuju/mKZFZKp5/PKf8Jdv/zDTIm8TwBvvtQKT4qmAYUkKTXRrO +OWK1pCakVLV7FGREDi+/bxhcQJt5yopLGT5NSoUF3RR+17KZ/5lSPEh5OMSprVyR +789KvY1z79JWt3zB6fIfQ936PyNh++SKxFmlnLuGK5wf58jefwSjGEkY2YAE66Y6 +8Kqg3/W8JsjTFBntBtD3xY1t0c4Hh2f3epQPrzwHx9pywgh+H2TIwnnUyEPLqdYp +SEsbnvdbLB8FZm2fwPZ1MZOZOGrKcnCMkMPE1DOIkxeFDx8xbeHRepSRJSbemY1l +tt+afAnM18mJf36gO8NnM56Me//FSTWbWaQlmUBAwSDlHxYfD9TgCjbBAgMBAAEw +DQYJKoZIhvcNAQEFBQADggIBAEt57zbZpIaQiw0BvZenLWhWvBA0j1cFk7eVG+Nl +Zo7+UniFH+1Io/gXJaJmJZ09d3ku4ZB+V44ka1N9J7qnnqXYOxRGT2H6owaWeOLl +FQ8tR1NQQA7p2uNWJclBsuPghzRCSFZw2auu8OKRtM/0VgbskNIN+H0EVhEeYjtd +ZzojPoa7AmH7P4SC1KMvY6qNmab9F8TBD19DPfoA/EpYboMQiK7DwPPuvrAdHcJB +KPLxyzabqFEqouwStqKUmKqbASOR+qJNac/RQTbN6yP4Lu9wTUm1OYaR4ot87dOR +ZhCznzlaJ2DsvFuoOKN/7Bezq+rXhIyCrH9VH0PjWwbO9FIfeZlHgmAmJnJCXb6F +bW6m+ha/63kiPU1NlTJRPukcR0vW/P0XSOcRvvje/07uJOOG5ypnQf6k7neR5e81 +1ZHPKCHba7bh08vKW5LbXwU4Ng7vRc42h6+iN0mogjj+B2oYt432L3howc8np2vF +eLCRxq/9pRut2QkfivT/GHkV/J+RxoEFDrZrTd15q1mLQnPCJOT+QmAMPfZydyZM +FsQUd6kzEWgZ4dHKqEikC0IBG+2xrrvHgKiB5Y1o0K/hEFfQOFCct6c9thXqMYhA +w/2HXXjfWLVBbGjJ4VemU1YFKyMZ+mxM1sJmPc/KkG/NjKf9wFFwFRpT3OIlF+BK +u8P4 +-----END CERTIFICATE----- diff --git a/packages/opentelemetry-exporter-collector/test/certs/server.csr b/packages/opentelemetry-exporter-collector/test/certs/server.csr new file mode 100644 index 0000000000..967316e171 --- /dev/null +++ b/packages/opentelemetry-exporter-collector/test/certs/server.csr @@ -0,0 +1,28 @@ +-----BEGIN CERTIFICATE REQUEST----- +MIIErzCCApcCAQAwajELMAkGA1UEBhMCQ0wxCzAJBgNVBAgMAlJNMRowGAYDVQQH +DBFPcGVuVGVsZW1ldHJ5VGVzdDENMAsGA1UECgwEVGVzdDEPMA0GA1UECwwGU2Vy +dmVyMRIwEAYDVQQDDAlsb2NhbGhvc3QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAw +ggIKAoICAQDUMB0X8o/3fB4dKoA5cXbUsZaEbPGbwSMLegHHHdYVKrPHQtHPVeV1 +znH5rrG9xaPDSl5+iCDwhMtbKRQnuBAVuKG0oJCRFXT8LDLF1Dy3pP+iuUurhBYZ +xi1CSee4AI4fSxnTEw6ebMyzu3U2Kx83RmWIZkwMogPSQzeomJaVpCuKdiAXDXYr +tuilqffrCSsPC8v+6OUA+MMnOoRqJNL9J8Ipl2aO/BCWAbugQxri8gIL6vMy1bIF +4uGmETrJla4NiCW3vPj7TwTcJKALkeEAt4UU1d218mXWyAtCmznpHoAB03l2MwKd +B1ZArG/7zi4hro7v5imRWSqefzyn/CXb/8w0yJvE8Ab77UCk+KpgGFJCk10azjli +taQmpFS1exRkRA4vv28YXECbecqKSxk+TUqFBd0Ufteymf+ZUjxIeTjEqa1cke/P +Sr2Nc+/SVrd8wenyH0Pd+j8jYfvkisRZpZy7hiucH+fI3n8EoxhJGNmABOumOvCq +oN/1vCbI0xQZ7QbQ98WNbdHOB4dn93qUD688B8facsIIfh9kyMJ51MhDy6nWKUhL +G573WywfBWZtn8D2dTGTmThqynJwjJDDxNQziJMXhQ8fMW3h0XqUkSUm3pmNZbbf +mnwJzNfJiX9+oDvDZzOejHv/xUk1m1mkJZlAQMEg5R8WHw/U4Ao2wQIDAQABoAAw +DQYJKoZIhvcNAQELBQADggIBAIBAt/12a6kkCFaRe256Umrj3/2DPA+gVqaVwlsi +xEGuO3GpBv7D6+lrlwNhLLSFOEkqoB4t/hjfGyabENXrCgyjMEoq/YKfwJvO4FPv +UkjaEWsCxmuwTS0qm8gXQy9PAwSI8EF2jOoRtvpCXl7bDQRJRIgKwZFI+jCEZvgj +Sk8fZGOH9yPEjx0KpvEw3jl/kbdSJu+CFTr981yLKjeG0lMknc/sQwH87tco4icj +t2Deaow6UOc0VaTmsWMLwIWrG/5TQPj+tL/600mBs5iQCOVio+hbzOHmDb48Ztao +CD4z8w8PAHxO79Vx0Wjt26cl6pKL58uke3G41Aq8//YLpSUUvIx0bYOwobDd4Ev5 +Emklvmcf3hAAzVQ7g8kDD82RDPRKtDl6e26+q2MQT31HuGbKB+5xpi113dSoB2CO +NSAgn3heoj5OM7heKwh6p6j0r1gT8WjXDMXQdKgekTGaUxeOSmccvMk4U0LN3JpK +JqaH178OucI9aRxGVjQFErW7xbKOViHP+NxNKj1pnerd7PX0wF/g107v2eSb6l/5 +K0UsM/l7MsINkx/1p+Qqu26t3i3Azw/MxKJqOVAlcb2LrACBj80BXBcJLW/My3kY +0XzK1siVSL17lL4KYBLO7kVR3F1+m+aQPrYJsLEKCAGxsfiFRBhXa6pfvp+fd5Hs +/xFM +-----END CERTIFICATE REQUEST----- diff --git a/packages/opentelemetry-exporter-collector/test/certs/server.key b/packages/opentelemetry-exporter-collector/test/certs/server.key new file mode 100644 index 0000000000..4831771d2b --- /dev/null +++ b/packages/opentelemetry-exporter-collector/test/certs/server.key @@ -0,0 +1,51 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIJKgIBAAKCAgEA1DAdF/KP93weHSqAOXF21LGWhGzxm8EjC3oBxx3WFSqzx0LR +z1Xldc5x+a6xvcWjw0pefogg8ITLWykUJ7gQFbihtKCQkRV0/CwyxdQ8t6T/orlL +q4QWGcYtQknnuACOH0sZ0xMOnmzMs7t1NisfN0ZliGZMDKID0kM3qJiWlaQrinYg +Fw12K7bopan36wkrDwvL/ujlAPjDJzqEaiTS/SfCKZdmjvwQlgG7oEMa4vICC+rz +MtWyBeLhphE6yZWuDYglt7z4+08E3CSgC5HhALeFFNXdtfJl1sgLQps56R6AAdN5 +djMCnQdWQKxv+84uIa6O7+YpkVkqnn88p/wl2//MNMibxPAG++1ApPiqYBhSQpNd +Gs45YrWkJqRUtXsUZEQOL79vGFxAm3nKiksZPk1KhQXdFH7Xspn/mVI8SHk4xKmt +XJHvz0q9jXPv0la3fMHp8h9D3fo/I2H75IrEWaWcu4YrnB/nyN5/BKMYSRjZgATr +pjrwqqDf9bwmyNMUGe0G0PfFjW3RzgeHZ/d6lA+vPAfH2nLCCH4fZMjCedTIQ8up +1ilISxue91ssHwVmbZ/A9nUxk5k4aspycIyQw8TUM4iTF4UPHzFt4dF6lJElJt6Z +jWW235p8CczXyYl/fqA7w2cznox7/8VJNZtZpCWZQEDBIOUfFh8P1OAKNsECAwEA +AQKCAgBaxLY9X0sMwHCVY2/0osAFnm5X+c6lJUqbhzapee7xoRHExKXB/umoqoaB +G6T3HEvAp9iiYhNNMFFZjsoLb6aZ1CCAh0swdTBVC4cwr2jF2nRspL1lApz9q5QC +zmCsirhBVLwYWgef58TtgdxTLsEswRV/8trHcKsX0B9IJPYNz2u80GlL0ztg2d7N +t1bRmVttFUvPoMsNzlyVNGgei+Ah4VciuZxqwBNMSDN+DBa9TG9pr7kXXujHsdV7 +V9WBFGGfckVIQzNzNctLbPN135KT3u20CwTL54R/C5YdiQ+N1LlHjrJfyNRuXgwc +oGdLHVkImYaVwyy2+6DKqn1FEw0SNrHQxbYHqHZf22F4tQYw8jE1Me1o89cG6n8t +RDZxm/7JcHg1Pq2WZMO61Xn+m2kTt6dVrPfl4n70CSZxaelV5UesBqbrZOHOiE4d +WQRGfhw7Sg+YFrNvevN/8p9Z99ubbRNflRgz5juZstk1j6ZESEO9fs1omgXGOeoN +BzAYp1odSAeeMlkfIaNo2QpLcBMnc6nQSYNld2QIg4k+1VhQUbkxRLGh4C3gs35I +ujRLRujCOye9ybv2MiDTqahK/mKCmldLWmXInUdMGTdMdUlYpBvtq1G8RBQHCwBl +2F3BTlITzKcVz3nvUiqqZzjm3eR4WEdTPMX4jr2iDR/kh61nfQKCAQEA9rgYScAp +KS3C8Fa6WX8vRPFTMOJGpo1GET38K7iRVO4SxWQqWzoH16ZE2bN01lyzjvfqPoRR +eOBdpyaJU6onjE+XLK9qoNgrW7HaInuNF4zWTndo4UwTXnE9l2qm3rMgjngXla6l +PuC6QVsPu2eGhmyWMtVKAmlMFYT2p7P+cSEwNZnCVmeMdviqO8aGMOuHNBEJ408O +oI41+rvffjogvNPnvDN1DQntl134CLxa+jlpAcr9KgVfMZpOqR+wvcV4JZSkPflp +HRFWlcOk2dWnqrIAkNcmVs+P6tB/d7sdj8hGHw0xJ9o+UYBmdJnj9N49dc9TggJo +asVIQ2CFKQVPgwKCAQEA3Ct7yVXwZwgxHBg4ouLaCXZ4/oouBjuwEtx+SPujs79S +IbM8v03YuxR3SWEqnB+P6g/Sx3EijYhz95nbzhN1gR482n+aHgtrMKGF8V4ROwOq +F3xXhx15qfn53G9SQvo1jOBsKQgxCH+MDrfa2rUGaesMVSIw3rMImiCqT329mDEX +oMpCfPUNPTXNIBJnMRcFkENK9XBN2tO7puvgi57EzseUP0jhnBYIZigjuYDDnys3 +xax5r7+o7ialJvUuuvlrHiYc+km8Qg9lDWloayZPOTGY1lEAwqdAyuVhXKF92hJe +o9Y4aD33FLaKrbHm/zfj4+L8Yuh+c0NXuhTkiLIpawKCAQEAhSgo260dyf7LxoFY +hDMTpQcGWkzVytBWr7mfn003CvqPIQAFqETytJ4lbMXhWkygEJqXT3SEsFOP2EYB +OimMvLq8Ib7vMq5ZAF1GGPRL2xkFFUZ3UZmInqFJl65VL77H5HzGZd/jicMqY1mt +bPzb6zMyAW+CSTjhen/PzAVmX1KFPXimHZI3ioJ9BlQIWuDTkPNdPdSOVXNLiO7b +GbpvrtpDqRywoP/pvpdV5gkapRBVL0WKS6KolRHuQHM9Jb8tMENAPb6dz7Vq4Nu9 +3l/k5Ui663FjXNkbmKU9FrbjppV12w54qESu+7fsFCR2ltNXonzqWjHIf0/Ix6yR +Uelu1wKCAQEAxUq17zHybfFaSImv3s6XgZlHTRi3q2A7JHuvMmlERWMxDv/VdLwm +dWYeioPmseZaiOzK/Wt1Agz/liWqYRzw09Yrw8RKb5fd4sMrCqI3oIFlHwyORoZ0 +KovVieG7fkdGS0ojwhUUE0BwWhQIqqlC6RD2iSdNUZJvJ+YTl43eoo2DVdNJBz50 +MaCPgqjbDZNKqf6TIiMTsP7BDhAatCJ+y6juQFNnz/2yYxCfCrDHG0+X96vZk1KU +52t73NAiouu0QFz45JPEfhHbhMwrBLFclqzJ/2qw2r0Tg31O5LnV099YLUpeW5MD +YO0+ke10SMlljiUt8tfR0CnNZ/Mm4xN7pwKCAQEAplZEytHOTmb5eaFYc8uiTAp+ +p1qCriIlw5T5akw1ESSKbEQTXmKqqwHP9pvFtg9Vd1M2ccmZT4Lk4+AL4sgHcs6p +asX3xz4/A9mqJKLruFd4lGhY14HV9JA1n0xVFnV5KK/7y+9Y1ZLvcGv/jzd/EXcL +T2OZ8wCTRdT6oi4+HsWaitHfNiJ1zvBgwWY9wEHofdPHIJwp8gNh6RD+M2WjHl4v +0GCGQaoEaIAePCn0R8WISviLhAymu9sIIov/WMBQQbsc03JlKSRsd/s5FYObUBfX +iBzCgMvuGWuFeBTB7LYgzina0IFwJqxy6Z7ySgZJKigPkhhrG/iD/QxuT2MvxQ== +-----END RSA PRIVATE KEY----- diff --git a/packages/opentelemetry-exporter-collector/test/common/CollectorExporter.test.ts b/packages/opentelemetry-exporter-collector/test/common/CollectorExporter.test.ts index 749de6b217..9ecfc170dd 100644 --- a/packages/opentelemetry-exporter-collector/test/common/CollectorExporter.test.ts +++ b/packages/opentelemetry-exporter-collector/test/common/CollectorExporter.test.ts @@ -19,21 +19,28 @@ import { ReadableSpan } from '@opentelemetry/tracing'; import * as assert from 'assert'; import * as sinon from 'sinon'; import { - CollectorExporter, - CollectorExporterConfig, -} from '../../src/CollectorExporter'; -import * as platform from '../../src/platform/index'; + CollectorExporterBase, + CollectorExporterConfigBase, +} from '../../src/CollectorExporterBase'; import { mockedReadableSpan } from '../helper'; +interface CollectorExporterConfig extends CollectorExporterConfigBase {} +class CollectorExporter extends CollectorExporterBase { + onInit() {} + onShutdown() {} + sendSpans() {} +} + describe('CollectorExporter - common', () => { let collectorExporter: CollectorExporter; let collectorExporterConfig: CollectorExporterConfig; describe('constructor', () => { let onInitSpy: any; + beforeEach(() => { - onInitSpy = sinon.stub(platform, 'onInit'); + onInitSpy = sinon.stub(CollectorExporter.prototype, 'onInit'); collectorExporterConfig = { hostName: 'foo', logger: new NoopLogger(), @@ -43,6 +50,7 @@ describe('CollectorExporter - common', () => { }; collectorExporter = new CollectorExporter(collectorExporterConfig); }); + afterEach(() => { onInitSpy.restore(); }); @@ -53,7 +61,6 @@ describe('CollectorExporter - common', () => { it('should call onInit', () => { assert.strictEqual(onInitSpy.callCount, 1); - assert.ok(onInitSpy.args[0][0] === collectorExporter); }); describe('when config contains certain params', () => { @@ -92,7 +99,7 @@ describe('CollectorExporter - common', () => { describe('export', () => { let spySend: any; beforeEach(() => { - spySend = sinon.stub(platform, 'sendSpans'); + spySend = sinon.stub(CollectorExporter.prototype, 'sendSpans'); collectorExporter = new CollectorExporter(collectorExporterConfig); }); afterEach(() => { @@ -136,7 +143,7 @@ describe('CollectorExporter - common', () => { describe('shutdown', () => { let onShutdownSpy: any; beforeEach(() => { - onShutdownSpy = sinon.stub(platform, 'onShutdown'); + onShutdownSpy = sinon.stub(CollectorExporter.prototype, 'onShutdown'); collectorExporterConfig = { hostName: 'foo', logger: new NoopLogger(), @@ -153,7 +160,7 @@ describe('CollectorExporter - common', () => { it('should call onShutdown', done => { collectorExporter.shutdown(); setTimeout(() => { - assert.ok(onShutdownSpy.args[0][0] === collectorExporter); + assert.equal(onShutdownSpy.callCount, 1); done(); }); }); diff --git a/packages/opentelemetry-exporter-collector/test/node/CollectorExporter.test.ts b/packages/opentelemetry-exporter-collector/test/node/CollectorExporter.test.ts index 027b3d7af0..3b7f35858c 100644 --- a/packages/opentelemetry-exporter-collector/test/node/CollectorExporter.test.ts +++ b/packages/opentelemetry-exporter-collector/test/node/CollectorExporter.test.ts @@ -17,6 +17,7 @@ import * as protoLoader from '@grpc/proto-loader'; import * as grpc from 'grpc'; import * as path from 'path'; +import * as fs from 'fs'; import { BasicTracerProvider, SimpleSpanProcessor, @@ -24,7 +25,7 @@ import { import * as assert from 'assert'; import * as sinon from 'sinon'; -import { CollectorExporter } from '../../src/CollectorExporter'; +import { CollectorExporter } from '../../src/platform/node'; import * as collectorTypes from '../../src/types'; import { @@ -37,94 +38,126 @@ const traceServiceProtoPath = 'opentelemetry/proto/collector/trace/v1/trace_service.proto'; const includeDirs = [path.resolve(__dirname, '../../src/platform/node/protos')]; -const address = '127.0.0.1:1501'; +const address = 'localhost:1501'; -describe('CollectorExporter - node', () => { - let collectorExporter: CollectorExporter; - let server: grpc.Server; - let exportedData: - | collectorTypes.opentelemetryProto.trace.v1.ResourceSpans - | undefined; +type TestParams = { + useTLS: boolean; +}; - before(done => { - server = new grpc.Server(); - protoLoader - .load(traceServiceProtoPath, { - 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.trace.v1.TraceService - .service, - { - Export: (data: { - request: collectorTypes.opentelemetryProto.collector.trace.v1.ExportTraceServiceRequest; - }) => { - try { - exportedData = data.request.resourceSpans[0]; - } catch (e) { - exportedData = undefined; - } - }, - } - ); - server.bind(address, grpc.ServerCredentials.createInsecure()); - server.start(); - done(); - }); - }); +const testCollectorExporter = (params: TestParams) => + describe(`CollectorExporter - node ${ + params.useTLS ? 'with TLS' : '' + }`, () => { + let collectorExporter: CollectorExporter; + let server: grpc.Server; + let exportedData: + | collectorTypes.opentelemetryProto.trace.v1.ResourceSpans + | undefined; - after(() => { - server.forceShutdown(); - }); + before(done => { + server = new grpc.Server(); + protoLoader + .load(traceServiceProtoPath, { + 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.trace.v1.TraceService + .service, + { + Export: (data: { + request: collectorTypes.opentelemetryProto.collector.trace.v1.ExportTraceServiceRequest; + }) => { + try { + exportedData = data.request.resourceSpans[0]; + } catch (e) { + exportedData = undefined; + } + }, + } + ); + let 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.bind(address, credentials); + server.start(); + done(); + }); + }); - beforeEach(done => { - collectorExporter = new CollectorExporter({ - serviceName: 'basic-service', - url: address, + after(() => { + server.forceShutdown(); }); - const provider = new BasicTracerProvider(); - provider.addSpanProcessor(new SimpleSpanProcessor(collectorExporter)); - done(); - }); + 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') + ) + : undefined; + collectorExporter = new CollectorExporter({ + serviceName: 'basic-service', + url: address, + credentials, + }); - afterEach(() => { - exportedData = undefined; - }); + const provider = new BasicTracerProvider(); + provider.addSpanProcessor(new SimpleSpanProcessor(collectorExporter)); + done(); + }); + + afterEach(() => { + exportedData = undefined; + }); - describe('export', () => { - it('should export spans', done => { - const responseSpy = sinon.spy(); - const spans = [Object.assign({}, mockedReadableSpan)]; - collectorExporter.export(spans, responseSpy); - setTimeout(() => { - assert.ok( - typeof exportedData !== 'undefined', - 'resource' + " doesn't exist" - ); - let spans; - let resource; - if (exportedData) { - spans = exportedData.instrumentationLibrarySpans[0].spans; - resource = exportedData.resource; - ensureExportedSpanIsCorrect(spans[0]); + describe('export', () => { + it('should export spans', done => { + const responseSpy = sinon.spy(); + const spans = [Object.assign({}, mockedReadableSpan)]; + collectorExporter.export(spans, responseSpy); + setTimeout(() => { + assert.ok( + typeof exportedData !== 'undefined', + 'resource' + " doesn't exist" + ); + let spans; + let resource; + if (exportedData) { + spans = exportedData.instrumentationLibrarySpans[0].spans; + resource = exportedData.resource; + ensureExportedSpanIsCorrect(spans[0]); - assert.ok(typeof resource !== 'undefined', "resource doesn't exist"); - if (resource) { - ensureResourceIsCorrect(resource); + assert.ok( + typeof resource !== 'undefined', + "resource doesn't exist" + ); + if (resource) { + ensureResourceIsCorrect(resource); + } } - } - done(); - }, 200); + done(); + }, 200); + }); }); }); -}); + +testCollectorExporter({ useTLS: true }); +testCollectorExporter({ useTLS: false });