@lopatnov/express-reverse-proxy 1.0.1 → 1.2.0

package/node_modules/@opencensus/propagation-b3/node_modules/@opencensus/core/build/src/trace/model/span.d.ts

@@ -0,0 +1,20 @@
+import { SpanBase } from './span-base';
+import * as types from './types';
+/** Defines a Span. */
+export declare class Span extends SpanBase implements types.Span {
+    private root;
+    /** set isRootSpan = true */
+    readonly isRootSpan: boolean;
+    /**
+     * Constructs a new SpanImpl instance.
+     * @param root
+     */
+    constructor(root: types.RootSpan);
+    /** Gets trace id of span. */
+    readonly traceId: string;
+    readonly traceState: string;
+    /** Starts the span instance. */
+    start(): void;
+    /** Ends the span. */
+    end(): void;
+}

package/node_modules/@opencensus/propagation-b3/node_modules/@opencensus/core/build/src/trace/model/span.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Copyright 2018, OpenCensus 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
+ *
+ *      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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger = require("../../common/console-logger");
+const span_base_1 = require("./span-base");
+/** Defines a Span. */
+class Span extends span_base_1.SpanBase {
+    /**
+     * Constructs a new SpanImpl instance.
+     * @param root
+     */
+    constructor(root) {
+        super();
+        /** set isRootSpan = true */
+        this.isRootSpan = false;
+        this.root = root;
+        this.logger = this.root.logger || logger.logger();
+        this.parentSpanId = root.id;
+    }
+    /** Gets trace id of span. */
+    get traceId() {
+        return this.root.traceId;
+    }
+    get traceState() {
+        return this.root.traceState;
+    }
+    /** Starts the span instance. */
+    start() {
+        super.start();
+        this.logger.debug('starting span  %o', {
+            traceId: this.traceId,
+            spanId: this.id,
+            name: this.name,
+            traceState: this.traceState
+        });
+    }
+    /** Ends the span. */
+    end() {
+        super.end();
+        this.logger.debug('ending span  %o', {
+            spanId: this.id,
+            traceId: this.traceId,
+            name: this.name,
+            startTime: this.startTime,
+            endTime: this.endTime,
+            duration: this.duration
+        });
+    }
+}
+exports.Span = Span;
+//# sourceMappingURL=span.js.map

package/node_modules/@opencensus/propagation-b3/node_modules/@opencensus/core/build/src/trace/model/tracer.d.ts

@@ -0,0 +1,95 @@
+/// <reference types="node" />
+/// <reference types="mocha" />
+import * as loggerTypes from '../../common/types';
+import * as configTypes from '../config/types';
+import { Propagation } from '../propagation/types';
+import * as samplerTypes from '../sampler/types';
+import * as types from './types';
+/**
+ * This class represent a tracer.
+ */
+export declare class CoreTracer implements types.Tracer {
+    /** Indicates if the tracer is active */
+    private activeLocal;
+    /** Manage context automatic propagation */
+    private contextManager;
+    /** A configuration for starting the tracer */
+    private config;
+    /** A list of end span event listeners */
+    private eventListenersLocal;
+    /** A list of ended root spans */
+    private endedTraces;
+    /** Bit to represent whether trace is sampled or not. */
+    private readonly IS_SAMPLED;
+    /** A sampler used to make sample decisions */
+    sampler: samplerTypes.Sampler;
+    /** A configuration for starting the tracer */
+    logger: loggerTypes.Logger;
+    /** Constructs a new TraceImpl instance. */
+    constructor();
+    /** Gets the current root span. */
+    /** Sets the current root span. */
+    currentRootSpan: types.RootSpan;
+    /** A propagation instance */
+    readonly propagation: Propagation;
+    /**
+     * Starts a tracer.
+     * @param config A tracer configuration object to start a tracer.
+     */
+    start(config: configTypes.TracerConfig): types.Tracer;
+    /** Stops the tracer. */
+    stop(): types.Tracer;
+    /** Gets the list of event listeners. */
+    readonly eventListeners: types.SpanEventListener[];
+    /** Indicates if the tracer is active or not. */
+    readonly active: boolean;
+    /**
+     * Starts a root span.
+     * @param options A TraceOptions object to start a root span.
+     * @param fn A callback function to run after starting a root span.
+     */
+    startRootSpan<T>(options: types.TraceOptions, fn: (root: types.RootSpan) => T): T;
+    onStartSpan(root: types.RootSpan): void;
+    /**
+     * Is called when a span is ended.
+     * @param root The ended span.
+     */
+    onEndSpan(root: types.RootSpan): void;
+    /**
+     * Registers an end span event listener.
+     * @param listener The listener to register.
+     */
+    registerSpanEventListener(listener: types.SpanEventListener): void;
+    /**
+     * Unregisters an end span event listener.
+     * @param listener The listener to unregister.
+     */
+    unregisterSpanEventListener(listener: types.SpanEventListener): void;
+    private notifyStartSpan(root);
+    private notifyEndSpan(root);
+    /** Clears the current root span. */
+    clearCurrentTrace(): void;
+    /**
+     * Starts a span.
+     * @param name The span name.
+     * @param type The span type.
+     * @param parentSpanId The parent span ID.
+     */
+    startChildSpan(name?: string, type?: string): types.Span;
+    /**
+     * Binds the trace context to the given function.
+     * This is necessary in order to create child spans correctly in functions
+     * that are called asynchronously (for example, in a network response
+     * handler).
+     * @param fn A function to which to bind the trace context.
+     */
+    wrap<T>(fn: types.Func<T>): types.Func<T>;
+    /**
+     * Binds the trace context to the given event emitter.
+     * This is necessary in order to create child spans correctly in event
+     * handlers.
+     * @param emitter An event emitter whose handlers should have
+     * the trace context binded to them.
+     */
+    wrapEmitter(emitter: NodeJS.EventEmitter): void;
+}

package/node_modules/@opencensus/propagation-b3/node_modules/@opencensus/core/build/src/trace/model/tracer.js

@@ -0,0 +1,229 @@
+"use strict";
+/**
+ * Copyright 2018, OpenCensus 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
+ *
+ *      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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger = require("../../common/console-logger");
+const cls = require("../../internal/cls");
+const sampler_1 = require("../sampler/sampler");
+const root_span_1 = require("./root-span");
+/**
+ * This class represent a tracer.
+ */
+class CoreTracer {
+    /** Constructs a new TraceImpl instance. */
+    constructor() {
+        /** A list of end span event listeners */
+        this.eventListenersLocal = [];
+        /** A list of ended root spans */
+        // @ts-ignore
+        this.endedTraces = [];
+        /** Bit to represent whether trace is sampled or not. */
+        this.IS_SAMPLED = 0x1;
+        /** A configuration for starting the tracer */
+        this.logger = logger.logger();
+        this.activeLocal = false;
+        this.contextManager = cls.createNamespace();
+        this.clearCurrentTrace();
+    }
+    /** Gets the current root span. */
+    get currentRootSpan() {
+        return this.contextManager.get('rootspan');
+    }
+    /** Sets the current root span. */
+    set currentRootSpan(root) {
+        if (this.contextManager.active) {
+            this.contextManager.set('rootspan', root);
+        }
+    }
+    /** A propagation instance */
+    get propagation() {
+        return this.config ? this.config.propagation : null;
+    }
+    /**
+     * Starts a tracer.
+     * @param config A tracer configuration object to start a tracer.
+     */
+    start(config) {
+        this.activeLocal = true;
+        this.config = config;
+        this.logger = this.config.logger || logger.logger();
+        this.sampler = sampler_1.SamplerBuilder.getSampler(config.samplingRate);
+        return this;
+    }
+    /** Stops the tracer. */
+    stop() {
+        this.activeLocal = false;
+        return this;
+    }
+    /** Gets the list of event listeners. */
+    get eventListeners() {
+        return this.eventListenersLocal;
+    }
+    /** Indicates if the tracer is active or not. */
+    get active() {
+        return this.activeLocal;
+    }
+    /**
+     * Starts a root span.
+     * @param options A TraceOptions object to start a root span.
+     * @param fn A callback function to run after starting a root span.
+     */
+    startRootSpan(options, fn) {
+        return this.contextManager.runAndReturn((root) => {
+            let newRoot = null;
+            if (this.active) {
+                let propagatedSample = null;
+                // if there is a context propagation, keep the decistion
+                if (options && options.spanContext) {
+                    if (options.spanContext.options) {
+                        propagatedSample =
+                            ((options.spanContext.options & this.IS_SAMPLED) !== 0);
+                    }
+                    if (!propagatedSample) {
+                        options.spanContext = null;
+                    }
+                }
+                const aRoot = new root_span_1.RootSpan(this, options);
+                const sampleDecision = propagatedSample ?
+                    propagatedSample :
+                    this.sampler.shouldSample(aRoot.traceId);
+                if (sampleDecision) {
+                    this.currentRootSpan = aRoot;
+                    aRoot.start();
+                    newRoot = aRoot;
+                }
+            }
+            else {
+                this.logger.debug('Tracer is inactive, can\'t start new RootSpan');
+            }
+            return fn(newRoot);
+        });
+    }
+    onStartSpan(root) {
+        if (this.active) {
+            if (!root) {
+                return this.logger.debug('cannot start trace - no active trace found');
+            }
+            if (this.currentRootSpan !== root) {
+                this.logger.debug('currentRootSpan != root on notifyStart. Need more investigation.');
+            }
+            this.notifyStartSpan(root);
+        }
+    }
+    /**
+     * Is called when a span is ended.
+     * @param root The ended span.
+     */
+    onEndSpan(root) {
+        if (this.active) {
+            if (!root) {
+                return this.logger.debug('cannot end trace - no active trace found');
+            }
+            if (this.currentRootSpan !== root) {
+                this.logger.debug('currentRootSpan != root on notifyEnd. Need more investigation.');
+            }
+            this.notifyEndSpan(root);
+        }
+    }
+    /**
+     * Registers an end span event listener.
+     * @param listener The listener to register.
+     */
+    registerSpanEventListener(listener) {
+        this.eventListenersLocal.push(listener);
+    }
+    /**
+     * Unregisters an end span event listener.
+     * @param listener The listener to unregister.
+     */
+    unregisterSpanEventListener(listener) {
+        const index = this.eventListenersLocal.indexOf(listener, 0);
+        if (index > -1) {
+            this.eventListeners.splice(index, 1);
+        }
+    }
+    notifyStartSpan(root) {
+        this.logger.debug('starting to notify listeners the start of rootspans');
+        if (this.eventListenersLocal && this.eventListenersLocal.length > 0) {
+            for (const listener of this.eventListenersLocal) {
+                listener.onStartSpan(root);
+            }
+        }
+    }
+    notifyEndSpan(root) {
+        if (this.active) {
+            this.logger.debug('starting to notify listeners the end of rootspans');
+            if (this.eventListenersLocal && this.eventListenersLocal.length > 0) {
+                for (const listener of this.eventListenersLocal) {
+                    listener.onEndSpan(root);
+                }
+            }
+        }
+        else {
+            this.logger.debug('this tracer is inactivate cant notify endspan');
+        }
+    }
+    /** Clears the current root span. */
+    clearCurrentTrace() {
+        this.currentRootSpan = null;
+    }
+    /**
+     * Starts a span.
+     * @param name The span name.
+     * @param type The span type.
+     * @param parentSpanId The parent span ID.
+     */
+    startChildSpan(name, type) {
+        let newSpan = null;
+        if (!this.currentRootSpan) {
+            this.logger.debug('no current trace found - must start a new root span first');
+        }
+        else {
+            newSpan = this.currentRootSpan.startChildSpan(name, type);
+        }
+        return newSpan;
+    }
+    /**
+     * Binds the trace context to the given function.
+     * This is necessary in order to create child spans correctly in functions
+     * that are called asynchronously (for example, in a network response
+     * handler).
+     * @param fn A function to which to bind the trace context.
+     */
+    wrap(fn) {
+        if (!this.active) {
+            return fn;
+        }
+        const namespace = this.contextManager;
+        return namespace.bind(fn);
+    }
+    /**
+     * Binds the trace context to the given event emitter.
+     * This is necessary in order to create child spans correctly in event
+     * handlers.
+     * @param emitter An event emitter whose handlers should have
+     * the trace context binded to them.
+     */
+    wrapEmitter(emitter) {
+        if (!this.active) {
+            return;
+        }
+        const namespace = this.contextManager;
+        namespace.bindEmitter(emitter);
+    }
+}
+exports.CoreTracer = CoreTracer;
+//# sourceMappingURL=tracer.js.map

package/node_modules/@opencensus/propagation-b3/node_modules/@opencensus/core/build/src/trace/model/types.d.ts

@@ -0,0 +1,245 @@
+/// <reference types="node" />
+/// <reference types="mocha" />
+/**
+ * Copyright 2018, OpenCensus 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
+ *
+ *      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.
+ */
+import * as loggerTypes from '../../common/types';
+import * as configTypes from '../config/types';
+import { Propagation } from '../propagation/types';
+import * as samplerTypes from '../sampler/types';
+/** Default type for functions */
+export declare type Func<T> = (...args: any[]) => T;
+/** Maps a label to a string, number or boolean. */
+export interface Attributes {
+    [attributeKey: string]: string | number | boolean;
+}
+/** A text annotation with a set of attributes. */
+export interface Annotation {
+    /** A user-supplied message describing the event. */
+    description: string;
+    /** A timestamp for the event event. */
+    timestamp: number;
+    /** A set of attributes on the annotation. */
+    attributes: Attributes;
+}
+/** An event describing a message sent/received between Spans. */
+export interface MessageEvent {
+    /** A timestamp for the event. */
+    timestamp: number;
+    /** Indicates whether the message was sent or received. */
+    type: string;
+    /** An identifier for the MessageEvent's message. */
+    id: string;
+}
+/**
+ * A pointer from the current span to another span in the same trace or in a
+ * different trace.
+ */
+export interface Link {
+    /** The trace ID for a trace within a project. */
+    traceId: string;
+    /** The span ID for a span within a trace. */
+    spanId: string;
+    /** The relationship of the current span relative to the linked. */
+    type: string;
+    /** A set of attributes on the link. */
+    attributes: Attributes;
+}
+/** Defines the trace options */
+export interface TraceOptions {
+    /** Root span name */
+    name: string;
+    /** Trace context */
+    spanContext?: SpanContext;
+    /** Span kind */
+    kind?: string;
+}
+export declare type TraceState = string;
+/** Defines the span context */
+export interface SpanContext {
+    /** Trace ID */
+    traceId: string;
+    /** Span ID */
+    spanId: string;
+    /** Options */
+    options?: number;
+    /** TraceState */
+    traceState?: TraceState;
+}
+/** Defines an end span event listener */
+export interface SpanEventListener {
+    /** Happens when a span is ended */
+    onStartSpan(span: RootSpan): void;
+    onEndSpan(span: RootSpan): void;
+}
+/** Interface for Span */
+export interface Span {
+    /** The Span ID of this span */
+    readonly id: string;
+    /** If the parent span is in another process. */
+    remoteParent: boolean;
+    /** The span ID of this span's parent. If it's a root span, must be empty */
+    parentSpanId: string;
+    /** The resource name of the span */
+    name: string;
+    /** Kind of span. */
+    kind: string;
+    /** An object to log information to */
+    logger: loggerTypes.Logger;
+    /** A final status for this span */
+    status: number;
+    /** A set of attributes, each in the format [KEY]:[VALUE] */
+    attributes: Attributes;
+    /** A text annotation with a set of attributes. */
+    annotations: Annotation[];
+    /** An event describing a message sent/received between Spans. */
+    messageEvents: MessageEvent[];
+    /** Pointers from the current span to another span */
+    links: Link[];
+    /** true if span is a RootSpan */
+    isRootSpan: boolean;
+    /** Trace id asscoiated with span. */
+    readonly traceId: string;
+    /** Trace state associated with span */
+    readonly traceState: TraceState;
+    /** Indicates if span was started. */
+    readonly started: boolean;
+    /** Indicates if span was ended. */
+    readonly ended: boolean;
+    /**
+     * Gives a timestap that indicates the span's start time in RFC3339 UTC
+     * "Zulu" format.
+     */
+    readonly startTime: Date;
+    /**
+     * Gives a timestap that indicates the span's end time in RFC3339 UTC
+     * "Zulu" format.
+     */
+    readonly endTime: Date;
+    /**
+     * Gives a timestap that indicates the span's duration in RFC3339 UTC
+     * "Zulu" format.
+     */
+    readonly duration: number;
+    /** Gives the TraceContext of the span. */
+    readonly spanContext: SpanContext;
+    /**
+     * Adds an atribute to the span.
+     * @param key Describes the value added.
+     * @param value The result of an operation.
+     */
+    addAttribute(key: string, value: string | number | boolean): void;
+    /**
+     * Adds an annotation to the span.
+     * @param description Describes the event.
+     * @param attributes A set of attributes on the annotation.
+     * @param timestamp A timestamp for this event.
+     */
+    addAnnotation(description: string, attributes?: Attributes, timestamp?: number): void;
+    /**
+     * Adds a link to the span.
+     * @param traceId The trace ID for a trace within a project.
+     * @param spanId The span ID for a span within a trace.
+     * @param type The relationship of the current span relative to the linked.
+     * @param attributes A set of attributes on the link.
+     */
+    addLink(traceId: string, spanId: string, type: string, attributes?: Attributes): void;
+    /**
+     * Adds a message event to the span.
+     * @param type The type of message event.
+     * @param id An identifier for the message event.
+     * @param timestamp A timestamp for this event.
+     */
+    addMessageEvent(type: string, id: string, timestamp?: number): void;
+    /** Starts a span. */
+    start(): void;
+    /** Ends a span. */
+    end(): void;
+    /** Forces to end a span. */
+    truncate(): void;
+}
+/** Interface for RootSpan */
+export interface RootSpan extends Span {
+    /** Get the span list from RootSpan instance */
+    readonly spans: Span[];
+    /** Starts a new Span instance in the RootSpan instance */
+    startChildSpan(name: string, type: string): Span;
+}
+/** Interface for Tracer */
+export interface Tracer extends SpanEventListener {
+    /** Get and set the currentRootSpan to tracer instance */
+    currentRootSpan: RootSpan;
+    /** A sampler that will decide if the span will be sampled or not */
+    sampler: samplerTypes.Sampler;
+    /** A configuration for starting the tracer */
+    logger: loggerTypes.Logger;
+    /** A propagation instance */
+    readonly propagation: Propagation;
+    /** Get the eventListeners from tracer instance */
+    readonly eventListeners: SpanEventListener[];
+    /** Get the active status from tracer instance */
+    readonly active: boolean;
+    /**
+     * Start a tracer instance
+     * @param config Configuration for tracer instace
+     * @returns A tracer instance started
+     */
+    start(config: configTypes.TracerConfig): Tracer;
+    /** Stop the tracer instance */
+    stop(): Tracer;
+    /**
+     * Start a new RootSpan to currentRootSpan
+     * @param options Options for tracer instance
+     * @param fn Callback function
+     * @returns The callback return
+     */
+    startRootSpan<T>(options: TraceOptions, fn: (root: RootSpan) => T): T;
+    /**
+     * Register a OnEndSpanEventListener on the tracer instance
+     * @param listener An OnEndSpanEventListener instance
+     */
+    registerSpanEventListener(listener: SpanEventListener): void;
+    /**
+     * Unregisters an end span event listener.
+     * @param listener The listener to unregister.
+     */
+    unregisterSpanEventListener(listener: SpanEventListener): void;
+    /** Clear the currentRootSpan from tracer instance */
+    clearCurrentTrace(): void;
+    /**
+     * Start a new Span instance to the currentRootSpan
+     * @param name Span name
+     * @param type Span type
+     * @param parentSpanId Parent SpanId
+     * @returns The new Span instance started
+     */
+    startChildSpan(name?: string, type?: string, parentSpanId?: string): Span;
+    /**
+     * Binds the trace context to the given function.
+     * This is necessary in order to create child spans correctly in functions
+     * that are called asynchronously (for example, in a network response
+     * handler).
+     * @param fn A function to which to bind the trace context.
+     */
+    wrap<T>(fn: Func<T>): Func<T>;
+    /**
+     * Binds the trace context to the given event emitter.
+     * This is necessary in order to create child spans correctly in event
+     * handlers.
+     * @param emitter An event emitter whose handlers should have
+     * the trace context binded to them.
+     */
+    wrapEmitter(emitter: NodeJS.EventEmitter): void;
+}

package/node_modules/@opencensus/propagation-b3/node_modules/@opencensus/core/build/src/trace/model/types.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Copyright 2018, OpenCensus 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
+ *
+ *      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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map