@lopatnov/express-reverse-proxy 1.0.1 → 1.2.0

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

@@ -0,0 +1,131 @@
+/**
+ * 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 { Logger } from '../../common/types';
+import * as configTypes from '../config/types';
+import * as types from './types';
+/** Defines a base model for spans. */
+export declare abstract class SpanBase implements types.Span {
+    protected className: string;
+    /** The clock used to mesure the beginning and ending of a span */
+    private clock;
+    /** Indicates if this span was started */
+    private startedLocal;
+    /** Indicates if this span was ended */
+    private endedLocal;
+    /** Indicates if this span was forced to end */
+    private truncated;
+    /** The Span ID of this span */
+    readonly id: string;
+    /** An object to log information to */
+    logger: Logger;
+    /** A set of attributes, each in the format [KEY]:[VALUE] */
+    attributes: types.Attributes;
+    /** A text annotation with a set of attributes. */
+    annotations: types.Annotation[];
+    /** An event describing a message sent/received between Spans */
+    messageEvents: types.MessageEvent[];
+    /** Pointers from the current span to another span */
+    links: types.Link[];
+    /** 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: types.SpanKind;
+    /** A final status for this span */
+    status: types.Status;
+    /** set isRootSpan  */
+    abstract readonly isRootSpan: boolean;
+    /** Trace Parameters */
+    activeTraceParams: configTypes.TraceParams;
+    /** The number of dropped attributes. */
+    droppedAttributesCount: number;
+    /** The number of dropped links. */
+    droppedLinksCount: number;
+    /** The number of dropped annotations. */
+    droppedAnnotationsCount: number;
+    /** The number of dropped message events. */
+    droppedMessageEventsCount: number;
+    /** Constructs a new SpanBaseModel instance. */
+    constructor();
+    /** Gets the trace ID. */
+    abstract readonly traceId: string;
+    /** Gets the trace state */
+    abstract readonly traceState: types.TraceState;
+    /** Indicates if span was started. */
+    readonly started: boolean;
+    /** Indicates if span was ended. */
+    readonly ended: boolean;
+    /**
+     * Gives a timestamp 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: types.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 time, in milliseconds. Defaults to Date.now()
+     */
+    addAnnotation(description: string, attributes?: types.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: types.LinkType, attributes?: types.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 time in milliseconds. Defaults to Date.now()
+     */
+    addMessageEvent(type: types.MessageEventType, id: string, timestamp?: number): void;
+    /**
+     * Sets a status to the span.
+     * @param code The canonical status code.
+     * @param message optional A developer-facing error message.
+     */
+    setStatus(code: types.CanonicalCode, message?: string): void;
+    /** Starts the span. */
+    start(): void;
+    /** Ends the span. */
+    end(): void;
+    /** Forces the span to end. */
+    truncate(): void;
+}

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

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const clock_1 = require("../../internal/clock");
+const util_1 = require("../../internal/util");
+const types = require("./types");
+const STATUS_OK = {
+    code: types.CanonicalCode.OK
+};
+/** Defines a base model for spans. */
+class SpanBase {
+    /** Constructs a new SpanBaseModel instance. */
+    constructor() {
+        /** The clock used to mesure the beginning and ending of a span */
+        this.clock = null;
+        /** Indicates if this span was started */
+        this.startedLocal = false;
+        /** Indicates if this span was ended */
+        this.endedLocal = false;
+        /** Indicates if this span was forced to end */
+        // @ts-ignore
+        this.truncated = false;
+        /** A set of attributes, each in the format [KEY]:[VALUE] */
+        this.attributes = {};
+        /** A text annotation with a set of attributes. */
+        this.annotations = [];
+        /** An event describing a message sent/received between Spans */
+        this.messageEvents = [];
+        /** Pointers from the current span to another span */
+        this.links = [];
+        /** The span ID of this span's parent. If it's a root span, must be empty */
+        this.parentSpanId = null;
+        /** The resource name of the span */
+        this.name = null;
+        /** Kind of span. */
+        this.kind = types.SpanKind.UNSPECIFIED;
+        /** A final status for this span */
+        this.status = STATUS_OK;
+        /** The number of dropped attributes. */
+        this.droppedAttributesCount = 0;
+        /** The number of dropped links. */
+        this.droppedLinksCount = 0;
+        /** The number of dropped annotations. */
+        this.droppedAnnotationsCount = 0;
+        /** The number of dropped message events. */
+        this.droppedMessageEventsCount = 0;
+        this.className = this.constructor.name;
+        this.id = util_1.randomSpanId();
+    }
+    /** Indicates if span was started. */
+    get started() {
+        return this.startedLocal;
+    }
+    /** Indicates if span was ended. */
+    get ended() {
+        return this.endedLocal;
+    }
+    /**
+     * Gives a timestamp that indicates the span's start time in RFC3339 UTC
+     * "Zulu" format.
+     */
+    get startTime() {
+        if (!this.clock) {
+            this.logger.debug('calling startTime() on null clock');
+            return null;
+        }
+        return this.clock.startTime;
+    }
+    /**
+     * Gives a timestap that indicates the span's end time in RFC3339 UTC
+     * "Zulu" format.
+     */
+    get endTime() {
+        if (!this.clock) {
+            this.logger.debug('calling endTime() on null clock');
+            return null;
+        }
+        return this.clock.endTime;
+    }
+    /**
+     * Gives a timestap that indicates the span's duration in RFC3339 UTC
+     * "Zulu" format.
+     */
+    get duration() {
+        if (!this.clock) {
+            this.logger.debug('calling duration() on null clock');
+            return null;
+        }
+        return this.clock.duration;
+    }
+    /** Gives the TraceContext of the span. */
+    get spanContext() {
+        return {
+            traceId: this.traceId,
+            spanId: this.id,
+            options: 0x1,
+            traceState: this.traceState
+        };
+    }
+    /**
+     * Adds an atribute to the span.
+     * @param key Describes the value added.
+     * @param value The result of an operation.
+     */
+    addAttribute(key, value) {
+        if (this.attributes[key]) {
+            delete this.attributes[key];
+        }
+        if (Object.keys(this.attributes).length >=
+            this.activeTraceParams.numberOfAttributesPerSpan) {
+            this.droppedAttributesCount++;
+            const attributeKeyToDelete = Object.keys(this.attributes).shift();
+            delete this.attributes[attributeKeyToDelete];
+        }
+        this.attributes[key] = value;
+    }
+    /**
+     * Adds an annotation to the span.
+     * @param description Describes the event.
+     * @param attributes A set of attributes on the annotation.
+     * @param timestamp A time, in milliseconds. Defaults to Date.now()
+     */
+    addAnnotation(description, attributes, timestamp = 0) {
+        if (this.annotations.length >=
+            this.activeTraceParams.numberOfAnnontationEventsPerSpan) {
+            this.annotations.shift();
+            this.droppedAnnotationsCount++;
+        }
+        this.annotations.push({
+            'description': description,
+            'attributes': attributes,
+            'timestamp': timestamp ? timestamp : Date.now(),
+        });
+    }
+    /**
+     * 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, spanId, type, attributes) {
+        if (this.links.length >= this.activeTraceParams.numberOfLinksPerSpan) {
+            this.links.shift();
+            this.droppedLinksCount++;
+        }
+        this.links.push({
+            'traceId': traceId,
+            'spanId': spanId,
+            'type': type,
+            'attributes': attributes
+        });
+    }
+    /**
+     * 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 time in milliseconds. Defaults to Date.now()
+     */
+    addMessageEvent(type, id, timestamp = 0) {
+        if (this.messageEvents.length >=
+            this.activeTraceParams.numberOfMessageEventsPerSpan) {
+            this.messageEvents.shift();
+            this.droppedMessageEventsCount++;
+        }
+        this.messageEvents.push({
+            'type': type,
+            'id': id,
+            'timestamp': timestamp ? timestamp : Date.now(),
+        });
+    }
+    /**
+     * Sets a status to the span.
+     * @param code The canonical status code.
+     * @param message optional A developer-facing error message.
+     */
+    setStatus(code, message) {
+        this.status = { code, message };
+    }
+    /** Starts the span. */
+    start() {
+        if (this.started) {
+            this.logger.debug('calling %s.start() on already started %s %o', this.className, this.className, { id: this.id, name: this.name, type: this.kind });
+            return;
+        }
+        this.clock = new clock_1.Clock();
+        this.startedLocal = true;
+    }
+    /** Ends the span. */
+    end() {
+        if (this.ended) {
+            this.logger.debug('calling %s.end() on already ended %s %o', this.className, this.className, { id: this.id, name: this.name, type: this.kind });
+            return;
+        }
+        if (!this.started) {
+            this.logger.error('calling %s.end() on un-started %s %o', this.className, this.className, { id: this.id, name: this.name, type: this.kind });
+            return;
+        }
+        this.startedLocal = false;
+        this.endedLocal = true;
+        this.clock.end();
+    }
+    /** Forces the span to end. */
+    truncate() {
+        this.truncated = true;
+        this.end();
+        this.logger.debug('truncating %s  %o', this.className, { id: this.id, name: this.name });
+    }
+}
+exports.SpanBase = SpanBase;
+//# sourceMappingURL=span-base.js.map

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

@@ -0,0 +1,35 @@
+/**
+ * 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 { 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/core/build/src/trace/model/span.js

@@ -0,0 +1,66 @@
+"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;
+        this.activeTraceParams = this.root.activeTraceParams;
+    }
+    /** 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/core/build/src/trace/model/tracer.d.ts

@@ -0,0 +1,112 @@
+/**
+ * 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.
+ */
+/// <reference types="node" />
+import * as loggerTypes from '../../common/types';
+import * as configTypes from '../config/types';
+import { TraceParams } 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;
+    /** A configuration object for trace parameters */
+    activeTraceParams: TraceParams;
+    /** 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;
+    private notifyEndSpan;
+    /** Clears the current root span. */
+    clearCurrentTrace(): void;
+    /**
+     * Starts a span.
+     * @param name The span name.
+     * @param kind optional The span kind.
+     * @param parentSpanId The parent span ID.
+     */
+    startChildSpan(name?: string, kind?: types.SpanKind): 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;
+}