feat: adding OpenTelemetry option

Author: kazagz

__tests__/core/runner.test.ts

@@ -24,6 +24,7 @@
  */
 
 import fs from 'fs';
+import { trace } from '@opentelemetry/api';
 import { Gatherer } from '../../src/core/gatherer';
 import Runner from '../../src/core/runner';
 import { step, journey, before, after } from '../../src/core';
@@ -42,6 +43,16 @@ import {
   RunOptions,
   StartEvent,
 } from '../../src/common_types';
+import { initOtel } from '../../src/otel/manager';
+import {
+  getJourneySpanOptions,
+  getStepSpanOptions,
+  endJourneySpan,
+  endStepSpan,
+} from '../../src/otel/events';
+
+jest.mock('../../src/otel/events');
+jest.mock('../../src/otel/manager');
 
 describe('runner', () => {
   let runner: Runner,
@@ -1014,4 +1025,55 @@ describe('runner', () => {
       });
     });
   });
+
+  describe('OpenTelemetry', () => {
+    it('skips init instrumentation when not enabled', async () => {
+      await runner._run({ ...defaultRunOptions, otel: false });
+      expect(initOtel).not.toHaveBeenCalled();
+    });
+
+    it('inits and shutdowns instrumentation when enabled', async () => {
+      const shutdown = jest.fn();
+      (initOtel as jest.Mock).mockImplementation(() => ({
+        shutdown,
+      }));
+      await runner._run({ ...defaultRunOptions, otel: true });
+      expect(initOtel).toHaveBeenCalled();
+      expect(shutdown).toHaveBeenCalled();
+    });
+
+    it('records spans for journey and steps', async () => {
+      jest.spyOn(trace, 'getTracer').mockReturnValue({
+        startActiveSpan: (
+          name: string,
+          options: any,
+          fn: (span: any) => Promise<void>
+        ) => {
+          return fn('span');
+        },
+      } as any);
+
+      const j1 = new Journey({ name: 'otel journey' }, noop);
+      const s1 = j1._addStep('step1', noop);
+      runner._addJourney(j1);
+
+      await runner._run({ ...defaultRunOptions, otel: true });
+
+      expect(trace.getTracer).toBeCalled();
+      expect(getJourneySpanOptions).toBeCalledWith(j1, expect.any(Date));
+      expect(endJourneySpan).toBeCalledWith({
+        span: 'span',
+        journey: j1,
+        endTime: expect.any(Number),
+      });
+
+      expect(getStepSpanOptions).toBeCalledWith(s1, expect.any(Date));
+      expect(endStepSpan).toBeCalledWith({
+        span: 'span',
+        step: s1,
+        data: {},
+        endTime: expect.any(Number),
+      });
+    });
+  });
 });

__tests__/dsl/journey.test.ts

@@ -23,7 +23,12 @@
  *
  */
 
+import { trace } from '@opentelemetry/api';
 import { Journey, Step } from '../../src/dsl';
+import { addMonitorConfigAttributesToSpan } from '../../src/otel';
+
+jest.mock('../../src/otel');
+jest.spyOn(trace, 'getActiveSpan').mockImplementation(() => 'span' as any);
 
 const noop = () => {};
 describe('Journey', () => {
@@ -44,4 +49,16 @@ describe('Journey', () => {
     expect(s2).toBeInstanceOf(Step);
     expect(journey.steps.length).toBe(2);
   });
+
+  describe('OpenTelemetry', () => {
+    it('updates span when otel enabled and monitor config is added', () => {
+      const journey = new Journey({ name: 'j1' }, noop);
+      journey._updateMonitor('config' as any);
+      expect(trace.getActiveSpan).toHaveBeenCalled();
+      expect(addMonitorConfigAttributesToSpan).toHaveBeenCalledWith(
+        'span',
+        'config'
+      );
+    });
+  });
 });

__tests__/helper.test.ts

@@ -34,6 +34,7 @@ import {
   microSecsToSeconds,
   wrapFnWithLocation,
   isMatch,
+  maskCredentialsInURL,
 } from '../src/helpers';
 
 it('indent message with seperator', () => {
@@ -146,3 +147,12 @@ it('match tags and names', () => {
   expect(isMatch(['bar'], 'foo', undefined, 'ba*')).toBe(true);
   expect(isMatch(['bar'], 'foo', undefined, 'test*')).toBe(false);
 });
+
+it('mask credentials in URL', () => {
+  expect(maskCredentialsInURL('https://user:password@example.com')).toBe(
+    'https://***:***@example.com/'
+  );
+  expect(maskCredentialsInURL('https://example.com')).toBe(
+    'https://example.com/'
+  );
+});

__tests__/options.test.ts

@@ -44,6 +44,7 @@ describe('options', () => {
       sandbox: false,
       screenshots: 'on',
       dryRun: true,
+      otel: true,
       match: 'check*',
       pauseOnError: true,
       config: join(__dirname, 'fixtures', 'synthetics.config.ts'),
@@ -52,9 +53,11 @@ describe('options', () => {
       environment: 'test',
       params: {},
       screenshots: 'on',
+      otel: false,
     });
     expect(await normalizeOptions(cliArgs)).toMatchObject({
       dryRun: true,
+      otel: true,
       environment: 'test',
       grepOpts: { match: 'check*' },
       params: {

__tests__/otel/duration-span-processor.test.ts

@@ -0,0 +1,156 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2020-present, Elastic NV
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+import { HrTime, metrics, SpanStatusCode } from '@opentelemetry/api';
+import { AttributeNames, DurationSpanProcessor } from '../../src/otel';
+import { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+import {
+  ATTR_URL_FULL,
+  METRIC_HTTP_CLIENT_REQUEST_DURATION,
+} from '@opentelemetry/semantic-conventions';
+
+const commonAttributes = {
+  [AttributeNames.JOURNEY_ID]: 'journey-id',
+  [AttributeNames.JOURNEY_NAME]: 'journey name',
+  [AttributeNames.STEP_NAME]: 'step name',
+};
+const createSpan = (
+  attributes: Record<string, any> = {},
+  duration: HrTime = [0, 0.1 * 1e9],
+  code: SpanStatusCode = SpanStatusCode.UNSET
+): ReadableSpan => {
+  const span: Partial<ReadableSpan> = {
+    duration,
+    status: { code },
+    attributes: {
+      ...commonAttributes,
+      ...attributes,
+      'extra.attribute': 'extra attribute value',
+    },
+  };
+  return span as ReadableSpan;
+};
+
+describe('DurationSpanProcessor', () => {
+  let records: [number, Record<string, any>][];
+  const mockedRecord = (duration: number, attributes: Record<string, any>) => {
+    records.push([duration, attributes]);
+  };
+  const mockedCreateGauge = jest.fn().mockReturnValue({ record: mockedRecord });
+  const mockedCreateHistogram = jest
+    .fn()
+    .mockReturnValue({ record: mockedRecord });
+
+  jest.spyOn(metrics, 'getMeter').mockImplementation(
+    () =>
+      ({
+        createGauge: mockedCreateGauge,
+        createHistogram: mockedCreateHistogram,
+      } as any)
+  );
+
+  beforeEach(() => {
+    records = [];
+  });
+
+  it('records gauge metrics for journeys and steps', () => {
+    const spans: ReadableSpan[] = [
+      createSpan({ [AttributeNames.SPAN_SUBTYPE]: 'journey' }, [0, 0.5 * 1e9]),
+      createSpan({ [AttributeNames.SPAN_SUBTYPE]: 'step' }),
+      createSpan(
+        { [AttributeNames.SPAN_SUBTYPE]: 'step' },
+        [1, 0],
+        SpanStatusCode.ERROR
+      ),
+      createSpan({ [AttributeNames.SPAN_SUBTYPE]: 'other' }),
+    ];
+    const spanProcessor = new DurationSpanProcessor();
+
+    spans.forEach(span => spanProcessor.onEnd(span));
+
+    expect(mockedCreateGauge).toBeCalledWith('synthetics.duration', {
+      description: 'Duration in seconds',
+      unit: 's',
+    });
+    expect(mockedCreateHistogram).not.toBeCalled();
+    expect(records).toEqual([
+      [
+        0.5,
+        {
+          ...commonAttributes,
+          'synthetics.status': 'success',
+          'synthetics.type': 'journey',
+        },
+      ],
+      [
+        0.1,
+        {
+          ...commonAttributes,
+          'synthetics.status': 'success',
+          'synthetics.type': 'step',
+        },
+      ],
+      [
+        1.0,
+        {
+          ...commonAttributes,
+          'synthetics.status': 'error',
+          'synthetics.type': 'step',
+        },
+      ],
+    ]);
+  });
+
+  it('records histogram metrics for requests', () => {
+    const spans: ReadableSpan[] = [
+      createSpan({ [ATTR_URL_FULL]: 'https://example.com/first' }, [
+        0,
+        0.5 * 1e9,
+      ]),
+      createSpan({
+        [ATTR_URL_FULL]: 'https://example.com/second',
+      }),
+      createSpan({
+        'span-without-url': 'value',
+      }),
+    ];
+    const spanProcessor = new DurationSpanProcessor();
+
+    spans.forEach(span => spanProcessor.onEnd(span));
+
+    expect(mockedCreateGauge).not.toBeCalled();
+    expect(mockedCreateHistogram).toBeCalledWith(
+      METRIC_HTTP_CLIENT_REQUEST_DURATION,
+      {
+        description: 'Duration in seconds for HTTP server spans',
+        unit: 's',
+      }
+    );
+    expect(records).toEqual([
+      [0.5, commonAttributes],
+      [0.1, commonAttributes],
+    ]);
+  });
+});