@lopatnov/express-reverse-proxy 1.0.1 → 1.2.0

package/node_modules/@opencensus/core/build/src/stats/bucket-boundaries.js

@@ -0,0 +1,90 @@
+"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");
+class BucketBoundaries {
+    constructor(boundaries, logger = defaultLogger) {
+        this.logger = logger.logger();
+        this.buckets = this.dropNegativeBucketBounds(boundaries);
+        this.bucketCounts = this.getBucketCounts(this.buckets);
+    }
+    /**
+     * Gets bucket boundaries
+     */
+    getBoundaries() {
+        return this.buckets;
+    }
+    /**
+     * Gets initial bucket counts
+     */
+    getCounts() {
+        return this.bucketCounts;
+    }
+    /**
+     * Drops negative (BucketBounds) are currently not supported by
+     * any of the backends that OC supports
+     * @param bucketBoundaries a list with the bucket boundaries
+     */
+    dropNegativeBucketBounds(bucketBoundaries) {
+        let negative = 0;
+        if (!bucketBoundaries)
+            return [];
+        const result = bucketBoundaries.reduce((accumulator, boundary, index) => {
+            if (boundary > 0) {
+                const nextBoundary = bucketBoundaries[index + 1];
+                this.validateBoundary(boundary, nextBoundary);
+                accumulator.push(boundary);
+            }
+            else {
+                negative++;
+            }
+            return accumulator;
+        }, []);
+        if (negative) {
+            this.logger.warn(`Dropping ${negative} negative bucket boundaries, the values must be strictly > 0.`);
+        }
+        return result;
+    }
+    /**
+     * Gets initial list of bucket counters
+     * @param buckets Bucket boundaries
+     */
+    getBucketCounts(buckets) {
+        if (!buckets)
+            return [];
+        const bucketsCount = new Array(buckets.length + 1);
+        bucketsCount.fill(0);
+        return bucketsCount;
+    }
+    /**
+     * Checks boundaries order and duplicates
+     * @param current Boundary
+     * @param next Next boundary
+     */
+    validateBoundary(current, next) {
+        if (next) {
+            if (current > next) {
+                this.logger.error('Bucket boundaries not sorted.');
+            }
+            if (current === next) {
+                this.logger.error('Bucket boundaries not unique.');
+            }
+        }
+    }
+}
+exports.BucketBoundaries = BucketBoundaries;
+//# sourceMappingURL=bucket-boundaries.js.map

package/node_modules/@opencensus/core/build/src/stats/metric-producer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { BaseMetricProducer } from '../metrics/export/base-metric-producer';
+import { Metric } from '../metrics/export/types';
+import { Stats } from './types';
+/**
+ * A MetricProducer producer that can be registered for exporting using
+ * MetricProducerManager.
+ */
+export declare class MetricProducerForStats extends BaseMetricProducer {
+    private statsManager;
+    /**
+     * @param statsManager The stats
+     */
+    constructor(statsManager: Stats);
+    /**
+     * Gets a collection of produced Metric`s to be exported.
+     * @returns {Metric[]} List of metrics
+     */
+    getMetrics(): Metric[];
+}

package/node_modules/@opencensus/core/build/src/stats/metric-producer.js

@@ -0,0 +1,40 @@
+"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 base_metric_producer_1 = require("../metrics/export/base-metric-producer");
+/**
+ * A MetricProducer producer that can be registered for exporting using
+ * MetricProducerManager.
+ */
+class MetricProducerForStats extends base_metric_producer_1.BaseMetricProducer {
+    /**
+     * @param statsManager The stats
+     */
+    constructor(statsManager) {
+        super();
+        this.statsManager = statsManager;
+    }
+    /**
+     * Gets a collection of produced Metric`s to be exported.
+     * @returns {Metric[]} List of metrics
+     */
+    getMetrics() {
+        return this.statsManager.getMetrics();
+    }
+}
+exports.MetricProducerForStats = MetricProducerForStats;
+//# sourceMappingURL=metric-producer.js.map

package/node_modules/@opencensus/core/build/src/stats/metric-utils.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 { LabelValue, MetricDescriptor } from '../metrics/export/types';
+import { TagValue } from '../tags/types';
+import { View } from './types';
+/** Utils to convert Stats data models to Metric data models */
+export declare class MetricUtils {
+    /**
+     * Gets the corresponding metric type for the given stats type.
+     * @param measure The measure for which to find a metric type
+     * @param aggregation The aggregation for which to find a metric type
+     * @returns {MetricDescriptorType} Type of metric descriptor
+     */
+    private static getType;
+    /**
+     * Gets a MetricDescriptor for given view.
+     * @param view The view for which to build a metric descriptor
+     * @returns {MetricDescriptor}
+     */
+    static viewToMetricDescriptor(view: View): MetricDescriptor;
+    /**
+     * Converts tag values to label values.
+     * @param tagValues
+     * @returns {LabelValue[]} List of label values
+     */
+    static tagValuesToLabelValues(tagValues: TagValue[]): LabelValue[];
+}

package/node_modules/@opencensus/core/build/src/stats/metric-utils.js

@@ -0,0 +1,83 @@
+"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 types_1 = require("../metrics/export/types");
+const types_2 = require("./types");
+/** Utils to convert Stats data models to Metric data models */
+class MetricUtils {
+    /**
+     * Gets the corresponding metric type for the given stats type.
+     * @param measure The measure for which to find a metric type
+     * @param aggregation The aggregation for which to find a metric type
+     * @returns {MetricDescriptorType} Type of metric descriptor
+     */
+    static getType(measure, aggregation) {
+        if (aggregation === types_2.AggregationType.SUM) {
+            switch (measure.type) {
+                case types_2.MeasureType.INT64:
+                    return types_1.MetricDescriptorType.CUMULATIVE_INT64;
+                case types_2.MeasureType.DOUBLE:
+                    return types_1.MetricDescriptorType.CUMULATIVE_DOUBLE;
+                default:
+                    throw new Error(`Unknown measure type ${measure.type}`);
+            }
+        }
+        else if (aggregation === types_2.AggregationType.COUNT) {
+            return types_1.MetricDescriptorType.CUMULATIVE_INT64;
+        }
+        else if (aggregation === types_2.AggregationType.DISTRIBUTION) {
+            return types_1.MetricDescriptorType.CUMULATIVE_DISTRIBUTION;
+        }
+        else if (aggregation === types_2.AggregationType.LAST_VALUE) {
+            switch (measure.type) {
+                case types_2.MeasureType.INT64:
+                    return types_1.MetricDescriptorType.GAUGE_INT64;
+                case types_2.MeasureType.DOUBLE:
+                    return types_1.MetricDescriptorType.GAUGE_DOUBLE;
+                default:
+                    throw new Error(`Unknown measure type ${measure.type}`);
+            }
+        }
+        throw new Error(`Unknown aggregation type ${aggregation}`);
+    }
+    /**
+     * Gets a MetricDescriptor for given view.
+     * @param view The view for which to build a metric descriptor
+     * @returns {MetricDescriptor}
+     */
+    static viewToMetricDescriptor(view) {
+        return {
+            name: view.name,
+            description: view.description,
+            unit: view.measure.unit,
+            type: MetricUtils.getType(view.measure, view.aggregation),
+            labelKeys: view.getColumns().map(
+            // TODO(mayurkale): add description
+            tagKey => ({ key: tagKey.name, description: '' }))
+        };
+    }
+    /**
+     * Converts tag values to label values.
+     * @param tagValues
+     * @returns {LabelValue[]} List of label values
+     */
+    static tagValuesToLabelValues(tagValues) {
+        return tagValues.map((tagValue) => ({ value: tagValue ? tagValue.value : null }));
+    }
+}
+exports.MetricUtils = MetricUtils;
+//# sourceMappingURL=metric-utils.js.map

package/node_modules/@opencensus/core/build/src/stats/recorder.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 { TagKey, TagValue } from '../tags/types';
+import { AggregationData, Measurement } from './types';
+export declare class Recorder {
+    static addMeasurement(aggregationData: AggregationData, measurement: Measurement): AggregationData;
+    /** Gets the tag values from tags and columns */
+    static getTagValues(tags: Map<TagKey, TagValue>, columns: TagKey[]): TagValue[];
+    private static addToDistribution;
+    private static addToSum;
+    private static addToCount;
+    private static addToLastValue;
+}

package/node_modules/@opencensus/core/build/src/stats/recorder.js

@@ -0,0 +1,76 @@
+"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 types_1 = require("./types");
+const UNKNOWN_TAG_VALUE = null;
+class Recorder {
+    static addMeasurement(aggregationData, measurement) {
+        aggregationData.timestamp = Date.now();
+        const value = measurement.measure.type === types_1.MeasureType.DOUBLE ?
+            measurement.value :
+            Math.trunc(measurement.value);
+        switch (aggregationData.type) {
+            case types_1.AggregationType.DISTRIBUTION:
+                return this.addToDistribution(aggregationData, value);
+            case types_1.AggregationType.SUM:
+                return this.addToSum(aggregationData, value);
+            case types_1.AggregationType.COUNT:
+                return this.addToCount(aggregationData, value);
+            default:
+                return this.addToLastValue(aggregationData, value);
+        }
+    }
+    /** Gets the tag values from tags and columns */
+    static getTagValues(tags, columns) {
+        return columns.map((tagKey) => (tags.get(tagKey) ||
+            /** replace not found key values by null. */ UNKNOWN_TAG_VALUE));
+    }
+    static addToDistribution(distributionData, value) {
+        distributionData.count += 1;
+        let bucketIndex = distributionData.buckets.findIndex(bucket => bucket > value);
+        if (bucketIndex < 0) {
+            bucketIndex = distributionData.buckets.length;
+        }
+        distributionData.bucketCounts[bucketIndex] += 1;
+        if (distributionData.count === 1) {
+            distributionData.mean = value;
+        }
+        distributionData.sum += value;
+        const oldMean = distributionData.mean;
+        distributionData.mean = distributionData.mean +
+            (value - distributionData.mean) / distributionData.count;
+        distributionData.sumOfSquaredDeviation =
+            distributionData.sumOfSquaredDeviation +
+                (value - oldMean) * (value - distributionData.mean);
+        distributionData.stdDeviation = Math.sqrt(distributionData.sumOfSquaredDeviation / distributionData.count);
+        return distributionData;
+    }
+    static addToSum(sumData, value) {
+        sumData.value += value;
+        return sumData;
+    }
+    static addToCount(countData, value) {
+        countData.value += 1;
+        return countData;
+    }
+    static addToLastValue(lastValueData, value) {
+        lastValueData.value = value;
+        return lastValueData;
+    }
+}
+exports.Recorder = Recorder;
+//# sourceMappingURL=recorder.js.map

package/node_modules/@opencensus/core/build/src/stats/stats.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 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 { StatsEventListener } from '../exporters/types';
+import { Metric } from '../metrics/export/types';
+import { TagMap } from '../tags/tag-map';
+import { TagKey } from '../tags/types';
+import { AggregationType, Measure, Measurement, MeasureUnit, Stats, View } from './types';
+export declare class BaseStats implements Stats {
+    /** A list of Stats exporters */
+    private statsEventListeners;
+    /** A map of Measures (name) to their corresponding Views */
+    private registeredViews;
+    /** An object to log information to */
+    private logger;
+    /** Singleton instance */
+    private static singletonInstance;
+    /**
+     * Creates stats
+     * @param logger
+     */
+    constructor(logger?: typeof defaultLogger);
+    /** Gets the stats instance. */
+    static readonly instance: Stats;
+    /**
+     * Registers a view to listen to new measurements in its measure.
+     * @param view The view to be registered
+     */
+    registerView(view: View): void;
+    /**
+     * Creates a view.
+     * @param name The view name
+     * @param measure The view measure
+     * @param aggregation The view aggregation type
+     * @param tagKeys The view columns (tag keys)
+     * @param description The view description
+     * @param bucketBoundaries The view bucket boundaries for a distribution
+     * aggregation type
+     */
+    createView(name: string, measure: Measure, aggregation: AggregationType, tagKeys: TagKey[], description: string, bucketBoundaries?: number[]): View;
+    /**
+     * Registers an exporter to send stats data to a service.
+     * @param exporter An stats exporter
+     */
+    registerExporter(exporter: StatsEventListener): void;
+    /**
+     * Creates a measure of type Double.
+     * @param name The measure name
+     * @param unit The measure unit
+     * @param description The measure description
+     */
+    createMeasureDouble(name: string, unit: MeasureUnit, description?: string): Measure;
+    /**
+     * Creates a measure of type Int64. Values must be integers up to
+     * Number.MAX_SAFE_INTERGER.
+     * @param name The measure name
+     * @param unit The measure unit
+     * @param description The measure description
+     */
+    createMeasureInt64(name: string, unit: MeasureUnit, description?: string): Measure;
+    /**
+     * Verifies whether all measurements has positive value
+     * @param measurements A list of measurements
+     * @returns {boolean} Whether values is positive
+     */
+    private hasNegativeValue;
+    /**
+     * Gets a collection of produced Metric`s to be exported.
+     * @returns {Metric[]} List of metrics
+     */
+    getMetrics(): Metric[];
+    /**
+     * Updates all views with the new measurements.
+     * @param measurements A list of measurements to record
+     * @param tags optional The tags to which the value is applied.
+     *  tags could either be explicitly passed to the method, or implicitly
+     *  read from current execution context.
+     */
+    record(measurements: Measurement[], tags?: TagMap): void;
+    /**
+     * Remove all registered Views and exporters from the stats.
+     */
+    clear(): void;
+}

package/node_modules/@opencensus/core/build/src/stats/stats.js

@@ -0,0 +1,169 @@
+"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 metrics_1 = require("../metrics/metrics");
+const tag_map_1 = require("../tags/tag-map");
+const metric_producer_1 = require("./metric-producer");
+const types_1 = require("./types");
+const view_1 = require("./view");
+class BaseStats {
+    /**
+     * Creates stats
+     * @param logger
+     */
+    constructor(logger = defaultLogger) {
+        /** A list of Stats exporters */
+        this.statsEventListeners = [];
+        /** A map of Measures (name) to their corresponding Views */
+        this.registeredViews = {};
+        this.logger = logger.logger();
+        // Create a new MetricProducerForStats and register it to
+        // MetricProducerManager when Stats is initialized.
+        const metricProducer = new metric_producer_1.MetricProducerForStats(this);
+        metrics_1.Metrics.getMetricProducerManager().add(metricProducer);
+    }
+    /** Gets the stats instance. */
+    static get instance() {
+        return this.singletonInstance || (this.singletonInstance = new this());
+    }
+    /**
+     * Registers a view to listen to new measurements in its measure.
+     * @param view The view to be registered
+     */
+    registerView(view) {
+        if (this.registeredViews[view.measure.name]) {
+            this.registeredViews[view.measure.name].push(view);
+        }
+        else {
+            this.registeredViews[view.measure.name] = [view];
+        }
+        view.registered = true;
+        // Notifies all exporters
+        for (const exporter of this.statsEventListeners) {
+            exporter.onRegisterView(view);
+        }
+    }
+    /**
+     * Creates a view.
+     * @param name The view name
+     * @param measure The view measure
+     * @param aggregation The view aggregation type
+     * @param tagKeys The view columns (tag keys)
+     * @param description The view description
+     * @param bucketBoundaries The view bucket boundaries for a distribution
+     * aggregation type
+     */
+    createView(name, measure, aggregation, tagKeys, description, bucketBoundaries) {
+        const view = new view_1.BaseView(name, measure, aggregation, tagKeys, description, bucketBoundaries);
+        return view;
+    }
+    /**
+     * Registers an exporter to send stats data to a service.
+     * @param exporter An stats exporter
+     */
+    registerExporter(exporter) {
+        this.statsEventListeners.push(exporter);
+        for (const measureName of Object.keys(this.registeredViews)) {
+            for (const view of this.registeredViews[measureName]) {
+                exporter.onRegisterView(view);
+            }
+        }
+        exporter.start();
+    }
+    /**
+     * Creates a measure of type Double.
+     * @param name The measure name
+     * @param unit The measure unit
+     * @param description The measure description
+     */
+    createMeasureDouble(name, unit, description) {
+        return { name, unit, type: types_1.MeasureType.DOUBLE, description };
+    }
+    /**
+     * Creates a measure of type Int64. Values must be integers up to
+     * Number.MAX_SAFE_INTERGER.
+     * @param name The measure name
+     * @param unit The measure unit
+     * @param description The measure description
+     */
+    createMeasureInt64(name, unit, description) {
+        return { name, unit, type: types_1.MeasureType.INT64, description };
+    }
+    /**
+     * Verifies whether all measurements has positive value
+     * @param measurements A list of measurements
+     * @returns {boolean} Whether values is positive
+     */
+    hasNegativeValue(measurements) {
+        return measurements.some(measurement => measurement.value < 0);
+    }
+    /**
+     * Gets a collection of produced Metric`s to be exported.
+     * @returns {Metric[]} List of metrics
+     */
+    getMetrics() {
+        const metrics = [];
+        for (const measureName of Object.keys(this.registeredViews)) {
+            for (const view of this.registeredViews[measureName]) {
+                metrics.push(view.getMetric(view.startTime));
+            }
+        }
+        return metrics;
+    }
+    /**
+     * Updates all views with the new measurements.
+     * @param measurements A list of measurements to record
+     * @param tags optional The tags to which the value is applied.
+     *  tags could either be explicitly passed to the method, or implicitly
+     *  read from current execution context.
+     */
+    record(measurements, tags) {
+        if (this.hasNegativeValue(measurements)) {
+            this.logger.warn(`Dropping measurments ${measurements}, value to record
+          must be non-negative.`);
+            return;
+        }
+        if (!tags) {
+            // TODO(mayurkale): read tags current execution context
+            tags = new tag_map_1.TagMap();
+        }
+        for (const measurement of measurements) {
+            const views = this.registeredViews[measurement.measure.name];
+            if (!views) {
+                break;
+            }
+            // Updates all views
+            for (const view of views) {
+                view.recordMeasurement(measurement, tags);
+            }
+            // Notifies all exporters
+            for (const exporter of this.statsEventListeners) {
+                exporter.onRecord(views, measurement, tags.tags);
+            }
+        }
+    }
+    /**
+     * Remove all registered Views and exporters from the stats.
+     */
+    clear() {
+        this.registeredViews = {};
+        this.statsEventListeners = [];
+    }
+}
+exports.BaseStats = BaseStats;
+//# sourceMappingURL=stats.js.map