@lopatnov/express-reverse-proxy 1.1.1 → 1.2.0

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

@@ -0,0 +1,188 @@
+/**
+ * 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 { Metric } from '../metrics/export/types';
+/** Tags are maps of names -> values */
+export interface Tags {
+    [key: string]: string;
+}
+/**
+ * Describes the type of the individual values/measurements recorded by an
+ * application. It includes information such as the type of measurement, the
+ * units of measurement and descriptive names for the data. This provides the
+ * fundamental type used for recording data.
+ */
+export interface Measure {
+    /**
+     * A string by which the measure will be referred to, e.g.
+     * "rpc_server_latency". Names MUST be unique within the library.
+     */
+    readonly name: string;
+    /** Describes the measure, e.g. "RPC latency in seconds". */
+    readonly description?: string;
+    /**
+     * Describes the unit used for the Measure. Follows the format described by
+     * http://unitsofmeasure.org/ucum.html.
+     */
+    readonly unit: MeasureUnit;
+    /** The type used for this Measure. */
+    readonly type: MeasureType;
+}
+/**
+ * Describes the unit used for the Measure. Should follows the format described
+ * by http://unitsofmeasure.org/ucum.html.
+ */
+export declare enum MeasureUnit {
+    UNIT = "1",
+    BYTE = "by",
+    KBYTE = "kb",
+    SEC = "s",
+    MS = "ms",
+    NS = "ns",
+}
+/** Describes the types of a Measure. It can be Int64 or a Double type. */
+export declare enum MeasureType {
+    INT64 = "INT64",
+    DOUBLE = "DOUBLE",
+}
+/** Describes a data point to be collected for a Measure. */
+export interface Measurement {
+    /** The measure to which the value is applied */
+    readonly measure: Measure;
+    /**
+     * The recorded value. If the measure has type INT64, value must be an integer
+     * up to Number.MAX_SAFE_INTERGER.
+     */
+    readonly value: number;
+    /** The tags to which the value is applied */
+    readonly tags: Tags;
+}
+/**
+ * Defines how individual measurements are broken down by tags and aggregated.
+ */
+export interface View {
+    /**
+     * A string by which the View will be referred to, e.g. "rpc_latency". Names
+     * MUST be unique within the library.
+     */
+    readonly name: string;
+    /** Describes the view, e.g. "RPC latency distribution" */
+    readonly description: string;
+    /** The Measure to which this view is applied. */
+    readonly measure: Measure;
+    /**
+     * An Aggregation describes how data collected is aggregated.
+     * There are four aggregation types: count, sum, lastValue and distirbution.
+     */
+    readonly aggregation: AggregationType;
+    /** The start time for this view */
+    readonly startTime: number;
+    /**
+     * The end time for this view - represents the last time a value was recorded
+     */
+    endTime: number;
+    /** true if the view was registered */
+    registered: boolean;
+    /**
+     * Records a measurement in the proper view's row. This method is used by
+     * Stats. User should prefer using Stats.record() instead.
+     *
+     * Measurements with measurement type INT64 will have its value truncated.
+     * @param measurement The measurement to record
+     */
+    recordMeasurement(measurement: Measurement): void;
+    /**
+     * Returns a snapshot of an AggregationData for that tags/labels values.
+     * @param tags The desired data's tags
+     */
+    getSnapshot(tags: Tags): AggregationData;
+    /** Gets the view's tag keys */
+    getColumns(): string[];
+    /** Gets view`s metric */
+    getMetric(): Metric;
+}
+/**
+ * Informs the type of the aggregation. It can be: count, sum, lastValue or
+ * distribution.
+ */
+export declare enum AggregationType {
+    COUNT = 0,
+    SUM = 1,
+    LAST_VALUE = 2,
+    DISTRIBUTION = 3,
+}
+/** Defines how data is collected and aggregated */
+export interface AggregationMetadata {
+    /** The aggregation type of the aggregation data */
+    readonly type: AggregationType;
+    /** The tags/labels that this AggregationData collects and aggregates */
+    readonly tags: Tags;
+    /** The latest timestamp a new data point was recorded */
+    timestamp: number;
+}
+/**
+ * Data collected and aggregated with this AggregationData will be summed
+ * up.
+ */
+export interface SumData extends AggregationMetadata {
+    type: AggregationType.SUM;
+    /** The current accumulated value */
+    value: number;
+}
+/**
+ * This AggregationData counts the number of measurements recorded.
+ */
+export interface CountData extends AggregationMetadata {
+    type: AggregationType.COUNT;
+    /** The current counted value */
+    value: number;
+}
+/**
+ * This AggregationData represents the last recorded value. This is useful
+ * when giving support to Gauges.
+ */
+export interface LastValueData extends AggregationMetadata {
+    type: AggregationType.LAST_VALUE;
+    /** The last recorded value */
+    value: number;
+}
+/** This AggregationData contains a histogram of the collected values. */
+export interface DistributionData extends AggregationMetadata {
+    type: AggregationType.DISTRIBUTION;
+    /** The first timestamp a datapoint was added */
+    readonly startTime: number;
+    /** Get the total count of all recorded values in the histogram */
+    count: number;
+    /** Sum of all recorded values in the histogram */
+    sum: number;
+    /** Get the computed mean value of all recorded values in the histogram */
+    mean: number;
+    /**
+     * Get the computed standard deviation of all recorded values in the
+     * histogram
+     */
+    stdDeviation: number;
+    /**
+     * Get the computed sum of squared deviations of all recorded values in the
+     * histogram.
+     */
+    sumOfSquaredDeviation: number;
+    /** Bucket distribution of the histogram */
+    buckets: Bucket[];
+    /** Buckets count */
+    bucketCounts?: number[];
+}
+export declare type Bucket = number;
+export declare type AggregationData = SumData | CountData | LastValueData | DistributionData;

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

@@ -0,0 +1,48 @@
+"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 });
+/**
+ * Describes the unit used for the Measure. Should follows the format described
+ * by http://unitsofmeasure.org/ucum.html.
+ */
+var MeasureUnit;
+(function (MeasureUnit) {
+    MeasureUnit["UNIT"] = "1";
+    MeasureUnit["BYTE"] = "by";
+    MeasureUnit["KBYTE"] = "kb";
+    MeasureUnit["SEC"] = "s";
+    MeasureUnit["MS"] = "ms";
+    MeasureUnit["NS"] = "ns"; // nanosecond
+})(MeasureUnit = exports.MeasureUnit || (exports.MeasureUnit = {}));
+/** Describes the types of a Measure. It can be Int64 or a Double type. */
+var MeasureType;
+(function (MeasureType) {
+    MeasureType["INT64"] = "INT64";
+    MeasureType["DOUBLE"] = "DOUBLE";
+})(MeasureType = exports.MeasureType || (exports.MeasureType = {}));
+/**
+ * Informs the type of the aggregation. It can be: count, sum, lastValue or
+ * distribution.
+ */
+var AggregationType;
+(function (AggregationType) {
+    AggregationType[AggregationType["COUNT"] = 0] = "COUNT";
+    AggregationType[AggregationType["SUM"] = 1] = "SUM";
+    AggregationType[AggregationType["LAST_VALUE"] = 2] = "LAST_VALUE";
+    AggregationType[AggregationType["DISTRIBUTION"] = 3] = "DISTRIBUTION";
+})(AggregationType = exports.AggregationType || (exports.AggregationType = {}));
+//# sourceMappingURL=types.js.map

package/node_modules/@opencensus/propagation-b3/node_modules/@opencensus/core/build/src/stats/view.d.ts

@@ -0,0 +1,118 @@
+/**
+ * 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 defaultLogger from '../common/console-logger';
+import { Metric } from '../metrics/export/types';
+import { AggregationData, AggregationType, Measure, Measurement, Tags, View } from './types';
+export declare class BaseView implements View {
+    /**
+     * A string by which the View will be referred to, e.g. "rpc_latency". Names
+     * MUST be unique within the library.
+     */
+    readonly name: string;
+    /** Describes the view, e.g. "RPC latency distribution" */
+    readonly description: string;
+    /** The Measure to which this view is applied. */
+    readonly measure: Measure;
+    /**
+     * A map of stringified tags representing columns labels or tag keys, concept
+     * similar to dimensions on multidimensional modeling, to AggregationData.
+     * If no Tags are provided, then, all data is recorded in a single
+     * aggregation.
+     */
+    private rows;
+    /**
+     * A list of tag keys that represents the possible column labels
+     */
+    private columns;
+    /**
+     * An Aggregation describes how data collected is aggregated.
+     * There are four aggregation types: count, sum, lastValue and distirbution.
+     */
+    readonly aggregation: AggregationType;
+    /** The start time for this view */
+    readonly startTime: number;
+    /** The bucket boundaries in a Distribution Aggregation */
+    private bucketBoundaries;
+    /**
+     * Cache a MetricDescriptor to avoid converting View to MetricDescriptor
+     * in the future.
+     */
+    private metricDescriptor;
+    /**
+     * The end time for this view - represents the last time a value was recorded
+     */
+    endTime: number;
+    /** true if the view was registered */
+    registered: boolean;
+    /** An object to log information to */
+    private logger;
+    /**
+     * Creates a new View instance. This constructor is used by Stats. User should
+     * prefer using Stats.createView() instead.
+     * @param name The view name
+     * @param measure The view measure
+     * @param aggregation The view aggregation type
+     * @param tagsKeys The Tags' keys that view will have
+     * @param description The view description
+     * @param bucketBoundaries The view bucket boundaries for a distribution
+     * aggregation type
+     * @param logger
+     */
+    constructor(name: string, measure: Measure, aggregation: AggregationType, tagsKeys: string[], description: string, bucketBoundaries?: number[], logger?: typeof defaultLogger);
+    /** Gets the view's tag keys */
+    getColumns(): string[];
+    /**
+     * Records a measurement in the proper view's row. This method is used by
+     * Stats. User should prefer using Stats.record() instead.
+     *
+     * Measurements with measurement type INT64 will have its value truncated.
+     * @param measurement The measurement to record
+     */
+    recordMeasurement(measurement: Measurement): void;
+    /**
+     * Encodes a Tags object into a key sorted string.
+     * @param tags The tags to encode
+     */
+    private encodeTags(tags);
+    /**
+     * Checks if tag keys and values have only printable characters.
+     * @param tags The tags to be checked
+     */
+    private invalidTags(tags);
+    /**
+     * Creates an empty aggregation data for a given tags.
+     * @param tags The tags for that aggregation data
+     */
+    private createAggregationData(tags);
+    /**
+     * Gets view`s metric
+     * @returns {Metric}
+     */
+    getMetric(): Metric;
+    /**
+     * Converts snapshot to point
+     * @param timestamp The timestamp
+     * @param data The aggregated data
+     * @returns {Point}
+     */
+    private toPoint(timestamp, data);
+    /**
+     * Returns a snapshot of an AggregationData for that tags/labels values.
+     * @param tags The desired data's tags
+     * @returns {AggregationData}
+     */
+    getSnapshot(tags: Tags): AggregationData;
+}

package/node_modules/@opencensus/propagation-b3/node_modules/@opencensus/core/build/src/stats/view.js

@@ -0,0 +1,201 @@
+"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 defaultLogger = require("../common/console-logger");
+const types_1 = require("../metrics/export/types");
+const bucket_boundaries_1 = require("./bucket-boundaries");
+const metric_utils_1 = require("./metric-utils");
+const recorder_1 = require("./recorder");
+const types_2 = require("./types");
+const RECORD_SEPARATOR = String.fromCharCode(30);
+const UNIT_SEPARATOR = String.fromCharCode(31);
+// String that has only printable characters
+const invalidString = /[^\u0020-\u007e]/;
+class BaseView {
+    /**
+     * Creates a new View instance. This constructor is used by Stats. User should
+     * prefer using Stats.createView() instead.
+     * @param name The view name
+     * @param measure The view measure
+     * @param aggregation The view aggregation type
+     * @param tagsKeys The Tags' keys that view will have
+     * @param description The view description
+     * @param bucketBoundaries The view bucket boundaries for a distribution
+     * aggregation type
+     * @param logger
+     */
+    constructor(name, measure, aggregation, tagsKeys, description, bucketBoundaries, logger = defaultLogger) {
+        /**
+         * A map of stringified tags representing columns labels or tag keys, concept
+         * similar to dimensions on multidimensional modeling, to AggregationData.
+         * If no Tags are provided, then, all data is recorded in a single
+         * aggregation.
+         */
+        this.rows = {};
+        /** true if the view was registered */
+        this.registered = false;
+        if (aggregation === types_2.AggregationType.DISTRIBUTION && !bucketBoundaries) {
+            throw new Error('No bucketBoundaries specified');
+        }
+        this.logger = logger.logger();
+        this.name = name;
+        this.description = description;
+        this.measure = measure;
+        this.columns = tagsKeys;
+        this.aggregation = aggregation;
+        this.startTime = Date.now();
+        this.bucketBoundaries = new bucket_boundaries_1.BucketBoundaries(bucketBoundaries);
+        this.metricDescriptor = metric_utils_1.MetricUtils.viewToMetricDescriptor(this);
+    }
+    /** Gets the view's tag keys */
+    getColumns() {
+        return this.columns;
+    }
+    /**
+     * Records a measurement in the proper view's row. This method is used by
+     * Stats. User should prefer using Stats.record() instead.
+     *
+     * Measurements with measurement type INT64 will have its value truncated.
+     * @param measurement The measurement to record
+     */
+    recordMeasurement(measurement) {
+        // Checks if measurement has valid tags
+        if (this.invalidTags(measurement.tags)) {
+            return;
+        }
+        // Checks if measurement has all tags in views
+        for (const tagKey of this.columns) {
+            if (!Object.keys(measurement.tags).some((key) => key === tagKey)) {
+                return;
+            }
+        }
+        const encodedTags = this.encodeTags(measurement.tags);
+        if (!this.rows[encodedTags]) {
+            this.rows[encodedTags] = this.createAggregationData(measurement.tags);
+        }
+        recorder_1.Recorder.addMeasurement(this.rows[encodedTags], measurement);
+    }
+    /**
+     * Encodes a Tags object into a key sorted string.
+     * @param tags The tags to encode
+     */
+    encodeTags(tags) {
+        return Object.keys(tags)
+            .sort()
+            .map(tagKey => {
+            return tagKey + UNIT_SEPARATOR + tags[tagKey];
+        })
+            .join(RECORD_SEPARATOR);
+    }
+    /**
+     * Checks if tag keys and values have only printable characters.
+     * @param tags The tags to be checked
+     */
+    invalidTags(tags) {
+        return Object.keys(tags).some(tagKey => {
+            return invalidString.test(tagKey) || invalidString.test(tags[tagKey]);
+        });
+    }
+    /**
+     * Creates an empty aggregation data for a given tags.
+     * @param tags The tags for that aggregation data
+     */
+    createAggregationData(tags) {
+        const aggregationMetadata = { tags, timestamp: Date.now() };
+        const { buckets, bucketCounts } = this.bucketBoundaries;
+        const bucketsCopy = Object.assign([], buckets);
+        const bucketCountsCopy = Object.assign([], bucketCounts);
+        switch (this.aggregation) {
+            case types_2.AggregationType.DISTRIBUTION:
+                return Object.assign({}, aggregationMetadata, { type: types_2.AggregationType.DISTRIBUTION, startTime: this.startTime, count: 0, sum: 0, mean: null, stdDeviation: null, sumOfSquaredDeviation: null, buckets: bucketsCopy, bucketCounts: bucketCountsCopy });
+            case types_2.AggregationType.SUM:
+                return Object.assign({}, aggregationMetadata, { type: types_2.AggregationType.SUM, value: 0 });
+            case types_2.AggregationType.COUNT:
+                return Object.assign({}, aggregationMetadata, { type: types_2.AggregationType.COUNT, value: 0 });
+            default:
+                return Object.assign({}, aggregationMetadata, { type: types_2.AggregationType.LAST_VALUE, value: undefined });
+        }
+    }
+    /**
+     * Gets view`s metric
+     * @returns {Metric}
+     */
+    getMetric() {
+        const { type } = this.metricDescriptor;
+        let startTimestamp;
+        // The moment when this point was recorded.
+        const [currentSeconds, currentNanos] = process.hrtime();
+        const now = { seconds: currentSeconds, nanos: currentNanos };
+        switch (type) {
+            case types_1.MetricDescriptorType.GAUGE_INT64:
+            case types_1.MetricDescriptorType.GAUGE_DOUBLE:
+                startTimestamp = null;
+                break;
+            default:
+                const [seconds, nanos] = process.hrtime();
+                // TODO (mayurkale): This should be set when create Cumulative view.
+                startTimestamp = { seconds, nanos };
+        }
+        const timeseries = [];
+        Object.keys(this.rows).forEach(key => {
+            const { tags } = this.rows[key];
+            const labelValues = metric_utils_1.MetricUtils.tagsToLabelValues(tags);
+            const point = this.toPoint(now, this.getSnapshot(tags));
+            if (startTimestamp) {
+                timeseries.push({ startTimestamp, labelValues, points: [point] });
+            }
+            else {
+                timeseries.push({ labelValues, points: [point] });
+            }
+        });
+        return { descriptor: this.metricDescriptor, timeseries };
+    }
+    /**
+     * Converts snapshot to point
+     * @param timestamp The timestamp
+     * @param data The aggregated data
+     * @returns {Point}
+     */
+    toPoint(timestamp, data) {
+        let value;
+        if (data.type === types_2.AggregationType.DISTRIBUTION) {
+            // TODO: Add examplar transition
+            const { count, sum, sumOfSquaredDeviation } = data;
+            value = {
+                count,
+                sum,
+                sumOfSquaredDeviation,
+                bucketOptions: { explicit: { bounds: data.buckets } },
+                buckets: data.bucketCounts
+            };
+        }
+        else {
+            value = data.value;
+        }
+        return { timestamp, value };
+    }
+    /**
+     * Returns a snapshot of an AggregationData for that tags/labels values.
+     * @param tags The desired data's tags
+     * @returns {AggregationData}
+     */
+    getSnapshot(tags) {
+        return this.rows[this.encodeTags(tags)];
+    }
+}
+exports.BaseView = BaseView;
+//# sourceMappingURL=view.js.map

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

@@ -0,0 +1,68 @@
+/**
+ * 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 { Exporter } from '../../exporters/types';
+import { PluginNames } from '../instrumentation/types';
+import { Propagation } from '../propagation/types';
+/** Interface configuration for a buffer. */
+export interface BufferConfig {
+    /** Maximum size of a buffer. */
+    bufferSize?: number;
+    /** Max time for a buffer can wait before being sent */
+    bufferTimeout?: number;
+    /** A logger object  */
+    logger?: Logger;
+}
+/** Defines tracer configuration parameters */
+export interface TracerConfig {
+    /** Determines the sampling rate. Ranges from 0.0 to 1.0 */
+    samplingRate?: number;
+    /** Determines the ignored (or blacklisted) URLs */
+    ignoreUrls?: Array<string | RegExp>;
+    /** A logger object  */
+    logger?: Logger;
+    /** A propagation instance */
+    propagation?: Propagation;
+}
+/** Available configuration options. */
+export interface TracingConfig {
+    /** level of logger - 0:disable, 1: error, 2: warn, 3: info, 4: debug  */
+    logLevel?: number;
+    /**
+     * The maximum number of characters reported on a label value.
+     */
+    maximumLabelValueSize?: number;
+    /**
+     * A list of trace instrumentations plugins to load.
+     * Each key is the name of the module to trace, and its
+     * value is the name of the package which has the plugin
+     * implementation.
+     * Ex.:
+     * plugins: {
+     *  'http': '@opencensus/opencensus-instrumentation-http',
+     *  'mongodb-core': '@opencensus/opencensus-instrumentation-mongodb-core',
+     *   ...
+     * }
+     * Any user-provided value will be added to the default list.
+     * It will override any default plugin for the same key.
+     */
+    plugins?: PluginNames;
+    /** An exporter object */
+    exporter?: Exporter;
+    /** An instance of a logger  */
+    logger?: Logger;
+}
+export declare type Config = TracingConfig & TracerConfig & BufferConfig;

package/node_modules/@opencensus/propagation-b3/node_modules/@opencensus/core/build/src/trace/config/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