feat: exporter collector TLS option

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: '<opentelemetry-collector-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`

packages/opentelemetry-exporter-collector/src/CollectorExporter.ts → 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;
 }

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/node';

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,
+          });
+        }
+      }
+    };
+  }
+}

packages/opentelemetry-exporter-collector/src/platform/browser/index.ts

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 
-export * from './sendSpans';
+export * from './CollectorExporter';