@lopatnov/express-reverse-proxy 1.3.0 → 2.0.0

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

@@ -1,20 +0,0 @@
-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

@@ -1,65 +0,0 @@
-"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

@@ -1,95 +0,0 @@
-/// <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

@@ -1,229 +0,0 @@
-"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

@@ -1,245 +0,0 @@
-/// <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

@@ -1,18 +0,0 @@
-"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