Merge branch 'master' into api-time-input

packages/opentelemetry-api/src/api/propagation.ts

@@ -96,6 +96,13 @@ export class PropagationAPI {
     return this._getGlobalPropagator().extract(context, carrier, getter);
   }
 
+  /**
+   * Return a list of all fields which may be used by the propagator.
+   */
+  public fields(): string[] {
+    return this._getGlobalPropagator().fields();
+  }
+
   /** Remove the global propagator */
   public disable() {
     delete _global[GLOBAL_PROPAGATION_API_KEY];

packages/opentelemetry-api/src/context/propagation/TextMapPropagator.ts

@@ -67,9 +67,6 @@ export interface TextMapPropagator<Carrier = any> {
 
   /**
    * Return a list of all fields which may be used by the propagator.
-   *
-   * This list should be used to clear fields before calling inject if a carrier is
-   * used more than once.
    */
   fields(): string[];
 }

packages/opentelemetry-api/src/trace/ProxyTracer.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import { Context } from '@opentelemetry/context-base';
 import { Span, SpanOptions, Tracer } from '..';
 import { NOOP_TRACER } from './NoopTracer';
 import { ProxyTracerProvider } from './ProxyTracerProvider';
@@ -31,8 +32,8 @@ export class ProxyTracer implements Tracer {
     public readonly version?: string
   ) {}
 
-  startSpan(name: string, options?: SpanOptions): Span {
-    return this._getTracer().startSpan(name, options);
+  startSpan(name: string, options?: SpanOptions, context?: Context): Span {
+    return this._getTracer().startSpan(name, options, context);
   }
 
   /**

packages/opentelemetry-api/test/api/api.test.ts

@@ -150,6 +150,13 @@ describe('API', () => {
         assert.strictEqual(data.carrier, carrier);
         assert.strictEqual(data.getter, getter);
       });
+
+      it('fields', () => {
+        api.propagation.setGlobalPropagator(new TestTextMapPropagation());
+
+        const fields = api.propagation.fields();
+        assert.deepStrictEqual(fields, ['TestField']);
+      });
     });
   });
 });

packages/opentelemetry-api/test/proxy-implementations/proxy-tracer.test.ts

@@ -26,15 +26,22 @@ import {
   Tracer,
   Span,
   NoopTracer,
+  ROOT_CONTEXT,
+  SpanOptions,
 } from '../../src';
 
 describe('ProxyTracer', () => {
   let provider: ProxyTracerProvider;
+  const sandbox = sinon.createSandbox();
 
   beforeEach(() => {
     provider = new ProxyTracerProvider();
   });
 
+  afterEach(() => {
+    sandbox.restore();
+  });
+
   describe('when no delegate is set', () => {
     it('should return proxy tracers', () => {
       const tracer = provider.getTracer('test');
@@ -61,7 +68,6 @@ describe('ProxyTracer', () => {
 
   describe('when delegate is set before getTracer', () => {
     let delegate: TracerProvider;
-    const sandbox = sinon.createSandbox();
     let getTracerStub: sinon.SinonStub;
 
     beforeEach(() => {
@@ -72,10 +78,6 @@ describe('ProxyTracer', () => {
       provider.setDelegate(delegate);
     });
 
-    afterEach(() => {
-      sandbox.restore();
-    });
-
     it('should return tracers directly from the delegate', () => {
       const tracer = provider.getTracer('test', 'v0');
 
@@ -114,5 +116,25 @@ describe('ProxyTracer', () => {
 
       assert.strictEqual(span, delegateSpan);
     });
+
+    it('should pass original arguments to DelegateTracer#startSpan', () => {
+      const startSpanStub = sandbox.stub(delegateTracer, 'startSpan');
+
+      const name = 'name1';
+      const options: SpanOptions = {};
+      const ctx = ROOT_CONTEXT.setValue(Symbol('test'), 1);
+      tracer.startSpan(name, options, ctx);
+
+      // Assert the proxy tracer has the full API of the NoopTracer
+      assert.strictEqual(
+        NoopTracer.prototype.startSpan.length,
+        ProxyTracer.prototype.startSpan.length
+      );
+      assert.deepStrictEqual(Object.getOwnPropertyNames(NoopTracer.prototype), [
+        'constructor',
+        'startSpan',
+      ]);
+      sandbox.assert.calledOnceWithExactly(startSpanStub, name, options, ctx);
+    });
   });
 });

packages/opentelemetry-core/src/platform/browser/environment.ts

@@ -17,15 +17,15 @@
 import {
   DEFAULT_ENVIRONMENT,
   ENVIRONMENT,
-  ENVIRONMENT_MAP,
+  RAW_ENVIRONMENT,
   parseEnvironment,
 } from '../../utils/environment';
 
 /**
  * Gets the environment variables
  */
 export function getEnv(): Required<ENVIRONMENT> {
-  const _window = window as typeof window & ENVIRONMENT_MAP;
+  const _window = window as typeof window & RAW_ENVIRONMENT;
   const globalEnv = parseEnvironment(_window);
   return Object.assign({}, DEFAULT_ENVIRONMENT, globalEnv);
 }

packages/opentelemetry-core/src/platform/node/environment.ts

@@ -14,17 +14,24 @@
  * limitations under the License.
  */
 
+import * as os from 'os';
 import {
   DEFAULT_ENVIRONMENT,
   ENVIRONMENT,
-  ENVIRONMENT_MAP,
+  RAW_ENVIRONMENT,
   parseEnvironment,
 } from '../../utils/environment';
 
 /**
  * Gets the environment variables
  */
 export function getEnv(): Required<ENVIRONMENT> {
-  const processEnv = parseEnvironment(process.env as ENVIRONMENT_MAP);
-  return Object.assign({}, DEFAULT_ENVIRONMENT, processEnv);
+  const processEnv = parseEnvironment(process.env as RAW_ENVIRONMENT);
+  return Object.assign(
+    {
+      HOSTNAME: os.hostname(),
+    },
+    DEFAULT_ENVIRONMENT,
+    processEnv
+  );
 }

packages/opentelemetry-core/src/utils/environment.ts

@@ -16,37 +16,78 @@
 
 import { LogLevel } from '../common/types';
 
-export type ENVIRONMENT_MAP = { [key: string]: string | number };
+const DEFAULT_LIST_SEPARATOR = ',';
 
 /**
  * Environment interface to define all names
  */
-export interface ENVIRONMENT {
-  OTEL_LOG_LEVEL?: LogLevel;
-  OTEL_NO_PATCH_MODULES?: string;
-  OTEL_SAMPLING_PROBABILITY?: number;
-  OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT?: number;
-  OTEL_SPAN_EVENT_COUNT_LIMIT?: number;
-  OTEL_SPAN_LINK_COUNT_LIMIT?: number;
-  OTEL_BSP_MAX_BATCH_SIZE?: number;
-  OTEL_BSP_SCHEDULE_DELAY_MILLIS?: number;
-}
 
-const ENVIRONMENT_NUMBERS: Partial<keyof ENVIRONMENT>[] = [
+const ENVIRONMENT_NUMBERS_KEYS = [
+  'OTEL_BSP_MAX_BATCH_SIZE',
+  'OTEL_BSP_SCHEDULE_DELAY_MILLIS',
   'OTEL_SAMPLING_PROBABILITY',
   'OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT',
   'OTEL_SPAN_EVENT_COUNT_LIMIT',
   'OTEL_SPAN_LINK_COUNT_LIMIT',
-  'OTEL_BSP_MAX_BATCH_SIZE',
-  'OTEL_BSP_SCHEDULE_DELAY_MILLIS',
-];
+] as const;
+
+type ENVIRONMENT_NUMBERS = {
+  [K in typeof ENVIRONMENT_NUMBERS_KEYS[number]]?: number;
+};
+
+function isEnvVarANumber(key: unknown): key is keyof ENVIRONMENT_NUMBERS {
+  return (
+    ENVIRONMENT_NUMBERS_KEYS.indexOf(key as keyof ENVIRONMENT_NUMBERS) > -1
+  );
+}
+
+const ENVIRONMENT_LISTS_KEYS = ['OTEL_NO_PATCH_MODULES'] as const;
+
+type ENVIRONMENT_LISTS = {
+  [K in typeof ENVIRONMENT_LISTS_KEYS[number]]?: string[];
+};
+
+function isEnvVarAList(key: unknown): key is keyof ENVIRONMENT_LISTS {
+  return ENVIRONMENT_LISTS_KEYS.indexOf(key as keyof ENVIRONMENT_LISTS) > -1;
+}
+
+export type ENVIRONMENT = {
+  CONTAINER_NAME?: string;
+  ECS_CONTAINER_METADATA_URI_V4?: string;
+  ECS_CONTAINER_METADATA_URI?: string;
+  HOSTNAME?: string;
+  KUBERNETES_SERVICE_HOST?: string;
+  NAMESPACE?: string;
+  OTEL_EXPORTER_JAEGER_AGENT_HOST?: string;
+  OTEL_EXPORTER_JAEGER_ENDPOINT?: string;
+  OTEL_EXPORTER_JAEGER_PASSWORD?: string;
+  OTEL_EXPORTER_JAEGER_USER?: string;
+  OTEL_LOG_LEVEL?: LogLevel;
+  OTEL_RESOURCE_ATTRIBUTES?: string;
+} & ENVIRONMENT_NUMBERS &
+  ENVIRONMENT_LISTS;
+
+export type RAW_ENVIRONMENT = {
+  [key: string]: string | number | undefined | string[];
+};
 
 /**
  * Default environment variables
  */
 export const DEFAULT_ENVIRONMENT: Required<ENVIRONMENT> = {
-  OTEL_NO_PATCH_MODULES: '',
+  CONTAINER_NAME: '',
+  ECS_CONTAINER_METADATA_URI_V4: '',
+  ECS_CONTAINER_METADATA_URI: '',
+  HOSTNAME: '',
+  KUBERNETES_SERVICE_HOST: '',
+  NAMESPACE: '',
+  OTEL_EXPORTER_JAEGER_AGENT_HOST: '',
+  OTEL_EXPORTER_JAEGER_ENDPOINT: '',
+  OTEL_EXPORTER_JAEGER_PASSWORD: '',
+  OTEL_EXPORTER_JAEGER_USER: '',
   OTEL_LOG_LEVEL: LogLevel.INFO,
+  OTEL_NO_PATCH_MODULES: [],
+  OTEL_RESOURCE_ATTRIBUTES: '',
   OTEL_SAMPLING_PROBABILITY: 1,
   OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT: 1000,
   OTEL_SPAN_EVENT_COUNT_LIMIT: 1000,
@@ -64,15 +105,14 @@ export const DEFAULT_ENVIRONMENT: Required<ENVIRONMENT> = {
  * @param max
  */
 function parseNumber(
-  name: keyof ENVIRONMENT,
-  environment: ENVIRONMENT_MAP | ENVIRONMENT,
-  values: ENVIRONMENT_MAP,
+  name: keyof ENVIRONMENT_NUMBERS,
+  environment: ENVIRONMENT,
+  values: RAW_ENVIRONMENT,
   min = -Infinity,
   max = Infinity
 ) {
   if (typeof values[name] !== 'undefined') {
     const value = Number(values[name] as string);
-
     if (!isNaN(value)) {
       if (value < min) {
         environment[name] = min;
@@ -85,6 +125,25 @@ function parseNumber(
   }
 }
 
+/**
+ * Parses list-like strings from input into output.
+ * @param name
+ * @param environment
+ * @param values
+ * @param separator
+ */
+function parseStringList(
+  name: keyof ENVIRONMENT_LISTS,
+  output: ENVIRONMENT,
+  input: RAW_ENVIRONMENT,
+  separator = DEFAULT_LIST_SEPARATOR
+) {
+  const givenValue = input[name];
+  if (typeof givenValue === 'string') {
+    output[name] = givenValue.split(separator).map(v => v.trim());
+  }
+}
+
 /**
  * Environmentally sets log level if valid log level string is provided
  * @param key
@@ -93,8 +152,8 @@ function parseNumber(
  */
 function setLogLevelFromEnv(
   key: keyof ENVIRONMENT,
-  environment: ENVIRONMENT_MAP | ENVIRONMENT,
-  values: ENVIRONMENT_MAP
+  environment: RAW_ENVIRONMENT | ENVIRONMENT,
+  values: RAW_ENVIRONMENT
 ) {
   const value = values[key];
   switch (typeof value === 'string' ? value.toUpperCase() : value) {
@@ -124,11 +183,12 @@ function setLogLevelFromEnv(
  * Parses environment values
  * @param values
  */
-export function parseEnvironment(values: ENVIRONMENT_MAP): ENVIRONMENT {
-  const environment: ENVIRONMENT_MAP = {};
+export function parseEnvironment(values: RAW_ENVIRONMENT): ENVIRONMENT {
+  const environment: ENVIRONMENT = {};
 
   for (const env in DEFAULT_ENVIRONMENT) {
     const key = env as keyof ENVIRONMENT;
+
     switch (key) {
       case 'OTEL_SAMPLING_PROBABILITY':
         parseNumber(key, environment, values, 0, 1);
@@ -139,11 +199,14 @@ export function parseEnvironment(values: ENVIRONMENT_MAP): ENVIRONMENT {
         break;
 
       default:
-        if (ENVIRONMENT_NUMBERS.indexOf(key) >= 0) {
+        if (isEnvVarANumber(key)) {
           parseNumber(key, environment, values);
+        } else if (isEnvVarAList(key)) {
+          parseStringList(key, environment, values);
         } else {
-          if (typeof values[key] !== 'undefined') {
-            environment[key] = values[key];
+          const value = values[key];
+          if (typeof value !== 'undefined' && value !== null) {
+            environment[key] = String(value);
           }
         }
     }