Update test framework: fix run_tests.py to support all test files, add auto-import-check for test files

node_modules/@opentelemetry/exporter-prometheus/build/src/PrometheusExporter.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="node" />
+import { MetricReader } from '@opentelemetry/sdk-metrics';
+import { IncomingMessage, ServerResponse } from 'http';
+import { ExporterConfig } from './export/types';
+export declare class PrometheusExporter extends MetricReader {
+    static readonly DEFAULT_OPTIONS: {
+        host: undefined;
+        port: number;
+        endpoint: string;
+        prefix: string;
+        appendTimestamp: boolean;
+        withResourceConstantLabels: undefined;
+    };
+    private readonly _host?;
+    private readonly _port;
+    private readonly _baseUrl;
+    private readonly _endpoint;
+    private readonly _server;
+    private readonly _prefix?;
+    private readonly _appendTimestamp;
+    private _serializer;
+    private _startServerPromise;
+    /**
+     * Constructor
+     * @param config Exporter configuration
+     * @param callback Callback to be called after a server was started
+     */
+    constructor(config?: ExporterConfig, callback?: (error: Error | void) => void);
+    onForceFlush(): Promise<void>;
+    /**
+     * Shuts down the export server and clears the registry
+     */
+    onShutdown(): Promise<void>;
+    /**
+     * Stops the Prometheus export server
+     */
+    stopServer(): Promise<void>;
+    /**
+     * Starts the Prometheus export server
+     */
+    startServer(): Promise<void>;
+    /**
+     * Request handler that responds with the current state of metrics
+     * @param _request Incoming HTTP request of server instance
+     * @param response HTTP response object used to response to request
+     */
+    getMetricsRequestHandler(_request: IncomingMessage, response: ServerResponse): void;
+    /**
+     * Request handler used by http library to respond to incoming requests
+     * for the current state of metrics by the Prometheus backend.
+     *
+     * @param request Incoming HTTP request to export server
+     * @param response HTTP response object used to respond to request
+     */
+    private _requestHandler;
+    /**
+     * Responds to incoming message with current state of all metrics.
+     */
+    private _exportMetrics;
+    /**
+     * Responds with 404 status code to all requests that do not match the configured endpoint.
+     */
+    private _notFound;
+}
+//# sourceMappingURL=PrometheusExporter.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/build/src/PrometheusExporter.js

@@ -0,0 +1,192 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry 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
+ *
+ *      https://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 });
+exports.PrometheusExporter = void 0;
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const http_1 = require("http");
+const PrometheusSerializer_1 = require("./PrometheusSerializer");
+/** Node.js v8.x compat */
+const url_1 = require("url");
+class PrometheusExporter extends sdk_metrics_1.MetricReader {
+    static DEFAULT_OPTIONS = {
+        host: undefined,
+        port: 9464,
+        endpoint: '/metrics',
+        prefix: '',
+        appendTimestamp: false,
+        withResourceConstantLabels: undefined,
+    };
+    _host;
+    _port;
+    _baseUrl;
+    _endpoint;
+    _server;
+    _prefix;
+    _appendTimestamp;
+    _serializer;
+    _startServerPromise;
+    // This will be required when histogram is implemented. Leaving here so it is not forgotten
+    // Histogram cannot have a attribute named 'le'
+    // private static readonly RESERVED_HISTOGRAM_LABEL = 'le';
+    /**
+     * Constructor
+     * @param config Exporter configuration
+     * @param callback Callback to be called after a server was started
+     */
+    constructor(config = {}, callback = () => { }) {
+        super({
+            aggregationSelector: _instrumentType => {
+                return {
+                    type: sdk_metrics_1.AggregationType.DEFAULT,
+                };
+            },
+            aggregationTemporalitySelector: _instrumentType => sdk_metrics_1.AggregationTemporality.CUMULATIVE,
+            metricProducers: config.metricProducers,
+        });
+        this._host =
+            config.host ||
+                process.env.OTEL_EXPORTER_PROMETHEUS_HOST ||
+                PrometheusExporter.DEFAULT_OPTIONS.host;
+        this._port =
+            config.port ||
+                Number(process.env.OTEL_EXPORTER_PROMETHEUS_PORT) ||
+                PrometheusExporter.DEFAULT_OPTIONS.port;
+        this._prefix = config.prefix || PrometheusExporter.DEFAULT_OPTIONS.prefix;
+        this._appendTimestamp =
+            typeof config.appendTimestamp === 'boolean'
+                ? config.appendTimestamp
+                : PrometheusExporter.DEFAULT_OPTIONS.appendTimestamp;
+        const _withResourceConstantLabels = config.withResourceConstantLabels ||
+            PrometheusExporter.DEFAULT_OPTIONS.withResourceConstantLabels;
+        // unref to prevent prometheus exporter from holding the process open on exit
+        this._server = (0, http_1.createServer)(this._requestHandler).unref();
+        this._serializer = new PrometheusSerializer_1.PrometheusSerializer(this._prefix, this._appendTimestamp, _withResourceConstantLabels);
+        this._baseUrl = `http://${this._host}:${this._port}/`;
+        this._endpoint = (config.endpoint || PrometheusExporter.DEFAULT_OPTIONS.endpoint).replace(/^([^/])/, '/$1');
+        if (config.preventServerStart !== true) {
+            this.startServer().then(callback, err => {
+                api_1.diag.error(err);
+                callback(err);
+            });
+        }
+        else if (callback) {
+            // Do not invoke callback immediately to avoid zalgo problem.
+            queueMicrotask(callback);
+        }
+    }
+    async onForceFlush() {
+        /** do nothing */
+    }
+    /**
+     * Shuts down the export server and clears the registry
+     */
+    onShutdown() {
+        return this.stopServer();
+    }
+    /**
+     * Stops the Prometheus export server
+     */
+    stopServer() {
+        if (!this._server) {
+            api_1.diag.debug('Prometheus stopServer() was called but server was never started.');
+            return Promise.resolve();
+        }
+        else {
+            return new Promise(resolve => {
+                this._server.close(err => {
+                    if (!err) {
+                        api_1.diag.debug('Prometheus exporter was stopped');
+                    }
+                    else {
+                        if (err.code !==
+                            'ERR_SERVER_NOT_RUNNING') {
+                            (0, core_1.globalErrorHandler)(err);
+                        }
+                    }
+                    resolve();
+                });
+            });
+        }
+    }
+    /**
+     * Starts the Prometheus export server
+     */
+    startServer() {
+        this._startServerPromise ??= new Promise((resolve, reject) => {
+            this._server.once('error', reject);
+            this._server.listen({
+                port: this._port,
+                host: this._host,
+            }, () => {
+                api_1.diag.debug(`Prometheus exporter server started: ${this._host}:${this._port}/${this._endpoint}`);
+                resolve();
+            });
+        });
+        return this._startServerPromise;
+    }
+    /**
+     * Request handler that responds with the current state of metrics
+     * @param _request Incoming HTTP request of server instance
+     * @param response HTTP response object used to response to request
+     */
+    getMetricsRequestHandler(_request, response) {
+        this._exportMetrics(response);
+    }
+    /**
+     * Request handler used by http library to respond to incoming requests
+     * for the current state of metrics by the Prometheus backend.
+     *
+     * @param request Incoming HTTP request to export server
+     * @param response HTTP response object used to respond to request
+     */
+    _requestHandler = (request, response) => {
+        if (request.url != null &&
+            new url_1.URL(request.url, this._baseUrl).pathname === this._endpoint) {
+            this._exportMetrics(response);
+        }
+        else {
+            this._notFound(response);
+        }
+    };
+    /**
+     * Responds to incoming message with current state of all metrics.
+     */
+    _exportMetrics = (response) => {
+        response.statusCode = 200;
+        response.setHeader('content-type', 'text/plain');
+        this.collect().then(collectionResult => {
+            const { resourceMetrics, errors } = collectionResult;
+            if (errors.length) {
+                api_1.diag.error('PrometheusExporter: metrics collection errors', ...errors);
+            }
+            response.end(this._serializer.serialize(resourceMetrics));
+        }, err => {
+            response.end(`# failed to export metrics: ${err}`);
+        });
+    };
+    /**
+     * Responds with 404 status code to all requests that do not match the configured endpoint.
+     */
+    _notFound = (response) => {
+        response.statusCode = 404;
+        response.end();
+    };
+}
+exports.PrometheusExporter = PrometheusExporter;
+//# sourceMappingURL=PrometheusExporter.js.map

node_modules/@opentelemetry/exporter-prometheus/build/src/PrometheusSerializer.d.ts

@@ -0,0 +1,17 @@
+import { ResourceMetrics } from '@opentelemetry/sdk-metrics';
+import { Resource } from '@opentelemetry/resources';
+export declare class PrometheusSerializer {
+    private _prefix;
+    private _appendTimestamp;
+    private _additionalAttributes;
+    private _withResourceConstantLabels;
+    constructor(prefix?: string, appendTimestamp?: boolean, withResourceConstantLabels?: RegExp);
+    serialize(resourceMetrics: ResourceMetrics): string;
+    private _filterResourceConstantLabels;
+    private _serializeScopeMetrics;
+    private _serializeMetricData;
+    private _serializeSingularDataPoint;
+    private _serializeHistogramDataPoint;
+    protected _serializeResource(resource: Resource): string;
+}
+//# sourceMappingURL=PrometheusSerializer.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/build/src/PrometheusSerializer.js

@@ -0,0 +1,259 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry 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
+ *
+ *      https://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 });
+exports.PrometheusSerializer = void 0;
+const api_1 = require("@opentelemetry/api");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const core_1 = require("@opentelemetry/core");
+function escapeString(str) {
+    return str.replace(/\\/g, '\\\\').replace(/\n/g, '\\n');
+}
+/**
+ * String Attribute values are converted directly to Prometheus attribute values.
+ * Non-string values are represented as JSON-encoded strings.
+ *
+ * `undefined` is converted to an empty string.
+ */
+function escapeAttributeValue(str = '') {
+    if (typeof str !== 'string') {
+        str = JSON.stringify(str);
+    }
+    return escapeString(str).replace(/"/g, '\\"');
+}
+const invalidCharacterRegex = /[^a-z0-9_]/gi;
+const multipleUnderscoreRegex = /_{2,}/g;
+/**
+ * Ensures metric names are valid Prometheus metric names by removing
+ * characters allowed by OpenTelemetry but disallowed by Prometheus.
+ *
+ * https://prometheus.io/docs/concepts/data_model/#metric-names-and-attributes
+ *
+ * 1. Names must match `[a-zA-Z_:][a-zA-Z0-9_:]*`
+ *
+ * 2. Colons are reserved for user defined recording rules.
+ * They should not be used by exporters or direct instrumentation.
+ *
+ * OpenTelemetry metric names are already validated in the Meter when they are created,
+ * and they match the format `[a-zA-Z][a-zA-Z0-9_.\-]*` which is very close to a valid
+ * prometheus metric name, so we only need to strip characters valid in OpenTelemetry
+ * but not valid in prometheus and replace them with '_'.
+ *
+ * @param name name to be sanitized
+ */
+function sanitizePrometheusMetricName(name) {
+    // replace all invalid characters with '_'
+    return name
+        .replace(invalidCharacterRegex, '_')
+        .replace(multipleUnderscoreRegex, '_');
+}
+/**
+ * @private
+ *
+ * Helper method which assists in enforcing the naming conventions for metric
+ * names in Prometheus
+ * @param name the name of the metric
+ * @param type the kind of metric
+ * @returns string
+ */
+function enforcePrometheusNamingConvention(name, data) {
+    // Prometheus requires that metrics of the Counter kind have "_total" suffix
+    if (!name.endsWith('_total') &&
+        data.dataPointType === sdk_metrics_1.DataPointType.SUM &&
+        data.isMonotonic) {
+        name = name + '_total';
+    }
+    return name;
+}
+function valueString(value) {
+    if (value === Infinity) {
+        return '+Inf';
+    }
+    else if (value === -Infinity) {
+        return '-Inf';
+    }
+    else {
+        // Handle finite numbers and NaN.
+        return `${value}`;
+    }
+}
+function toPrometheusType(metricData) {
+    switch (metricData.dataPointType) {
+        case sdk_metrics_1.DataPointType.SUM:
+            if (metricData.isMonotonic) {
+                return 'counter';
+            }
+            return 'gauge';
+        case sdk_metrics_1.DataPointType.GAUGE:
+            return 'gauge';
+        case sdk_metrics_1.DataPointType.HISTOGRAM:
+            return 'histogram';
+        default:
+            return 'untyped';
+    }
+}
+function stringify(metricName, attributes, value, timestamp, additionalAttributes) {
+    let hasAttribute = false;
+    let attributesStr = '';
+    for (const [key, val] of Object.entries(attributes)) {
+        const sanitizedAttributeName = sanitizePrometheusMetricName(key);
+        hasAttribute = true;
+        attributesStr += `${attributesStr.length > 0 ? ',' : ''}${sanitizedAttributeName}="${escapeAttributeValue(val)}"`;
+    }
+    if (additionalAttributes) {
+        for (const [key, val] of Object.entries(additionalAttributes)) {
+            const sanitizedAttributeName = sanitizePrometheusMetricName(key);
+            hasAttribute = true;
+            attributesStr += `${attributesStr.length > 0 ? ',' : ''}${sanitizedAttributeName}="${escapeAttributeValue(val)}"`;
+        }
+    }
+    if (hasAttribute) {
+        metricName += `{${attributesStr}}`;
+    }
+    return `${metricName} ${valueString(value)}${timestamp !== undefined ? ' ' + String(timestamp) : ''}\n`;
+}
+const NO_REGISTERED_METRICS = '# no registered metrics';
+class PrometheusSerializer {
+    _prefix;
+    _appendTimestamp;
+    _additionalAttributes;
+    _withResourceConstantLabels;
+    constructor(prefix, appendTimestamp = false, withResourceConstantLabels) {
+        if (prefix) {
+            this._prefix = prefix + '_';
+        }
+        this._appendTimestamp = appendTimestamp;
+        this._withResourceConstantLabels = withResourceConstantLabels;
+    }
+    serialize(resourceMetrics) {
+        let str = '';
+        this._additionalAttributes = this._filterResourceConstantLabels(resourceMetrics.resource.attributes, this._withResourceConstantLabels);
+        for (const scopeMetrics of resourceMetrics.scopeMetrics) {
+            str += this._serializeScopeMetrics(scopeMetrics);
+        }
+        if (str === '') {
+            str += NO_REGISTERED_METRICS;
+        }
+        return this._serializeResource(resourceMetrics.resource) + str;
+    }
+    _filterResourceConstantLabels(attributes, pattern) {
+        if (pattern) {
+            const filteredAttributes = {};
+            for (const [key, value] of Object.entries(attributes)) {
+                if (key.match(pattern)) {
+                    filteredAttributes[key] = value;
+                }
+            }
+            return filteredAttributes;
+        }
+        return;
+    }
+    _serializeScopeMetrics(scopeMetrics) {
+        let str = '';
+        for (const metric of scopeMetrics.metrics) {
+            str += this._serializeMetricData(metric) + '\n';
+        }
+        return str;
+    }
+    _serializeMetricData(metricData) {
+        let name = sanitizePrometheusMetricName(escapeString(metricData.descriptor.name));
+        if (this._prefix) {
+            name = `${this._prefix}${name}`;
+        }
+        const dataPointType = metricData.dataPointType;
+        name = enforcePrometheusNamingConvention(name, metricData);
+        const help = `# HELP ${name} ${escapeString(metricData.descriptor.description || 'description missing')}`;
+        const unit = metricData.descriptor.unit
+            ? `\n# UNIT ${name} ${escapeString(metricData.descriptor.unit)}`
+            : '';
+        const type = `# TYPE ${name} ${toPrometheusType(metricData)}`;
+        let results = '';
+        switch (dataPointType) {
+            case sdk_metrics_1.DataPointType.SUM:
+            case sdk_metrics_1.DataPointType.GAUGE: {
+                results = metricData.dataPoints
+                    .map(it => this._serializeSingularDataPoint(name, metricData, it))
+                    .join('');
+                break;
+            }
+            case sdk_metrics_1.DataPointType.HISTOGRAM: {
+                results = metricData.dataPoints
+                    .map(it => this._serializeHistogramDataPoint(name, metricData, it))
+                    .join('');
+                break;
+            }
+            default: {
+                api_1.diag.error(`Unrecognizable DataPointType: ${dataPointType} for metric "${name}"`);
+            }
+        }
+        return `${help}${unit}\n${type}\n${results}`.trim();
+    }
+    _serializeSingularDataPoint(name, data, dataPoint) {
+        let results = '';
+        name = enforcePrometheusNamingConvention(name, data);
+        const { value, attributes } = dataPoint;
+        const timestamp = (0, core_1.hrTimeToMilliseconds)(dataPoint.endTime);
+        results += stringify(name, attributes, value, this._appendTimestamp ? timestamp : undefined, this._additionalAttributes);
+        return results;
+    }
+    _serializeHistogramDataPoint(name, data, dataPoint) {
+        let results = '';
+        name = enforcePrometheusNamingConvention(name, data);
+        const attributes = dataPoint.attributes;
+        const histogram = dataPoint.value;
+        const timestamp = (0, core_1.hrTimeToMilliseconds)(dataPoint.endTime);
+        /** Histogram["bucket"] is not typed with `number` */
+        for (const key of ['count', 'sum']) {
+            const value = histogram[key];
+            if (value != null)
+                results += stringify(name + '_' + key, attributes, value, this._appendTimestamp ? timestamp : undefined, this._additionalAttributes);
+        }
+        let cumulativeSum = 0;
+        const countEntries = histogram.buckets.counts.entries();
+        let infiniteBoundaryDefined = false;
+        for (const [idx, val] of countEntries) {
+            cumulativeSum += val;
+            const upperBound = histogram.buckets.boundaries[idx];
+            /** HistogramAggregator is producing different boundary output -
+             * in one case not including infinity values, in other -
+             * full, e.g. [0, 100] and [0, 100, Infinity]
+             * we should consider that in export, if Infinity is defined, use it
+             * as boundary
+             */
+            if (upperBound === undefined && infiniteBoundaryDefined) {
+                break;
+            }
+            if (upperBound === Infinity) {
+                infiniteBoundaryDefined = true;
+            }
+            results += stringify(name + '_bucket', attributes, cumulativeSum, this._appendTimestamp ? timestamp : undefined, Object.assign({}, this._additionalAttributes ?? {}, {
+                le: upperBound === undefined || upperBound === Infinity
+                    ? '+Inf'
+                    : String(upperBound),
+            }));
+        }
+        return results;
+    }
+    _serializeResource(resource) {
+        const name = 'target_info';
+        const help = `# HELP ${name} Target metadata`;
+        const type = `# TYPE ${name} gauge`;
+        const results = stringify(name, resource.attributes, 1).trim();
+        return `${help}\n${type}\n${results}\n`;
+    }
+}
+exports.PrometheusSerializer = PrometheusSerializer;
+//# sourceMappingURL=PrometheusSerializer.js.map

node_modules/@opentelemetry/exporter-prometheus/build/src/export/types.d.ts

@@ -0,0 +1,54 @@
+import { MetricProducer } from '@opentelemetry/sdk-metrics';
+/**
+ * Configuration interface for prometheus exporter
+ */
+export interface ExporterConfig {
+    /**
+     * App prefix for metrics, if needed
+     *
+     * @default ''
+     * */
+    prefix?: string;
+    /**
+     * Append timestamp to metrics
+     * @default true
+     */
+    appendTimestamp?: boolean;
+    /**
+     * Endpoint the metrics should be exposed at with preceding slash
+     * @default '/metrics'
+     */
+    endpoint?: string;
+    /**
+     * @default undefined (all interfaces)
+     */
+    host?: string;
+    /**
+     * Port number for Prometheus exporter server
+     *
+     * Default registered port is 9464:
+     * https://github.com/prometheus/prometheus/wiki/Default-port-allocations
+     * @default 9464
+     */
+    port?: number;
+    /**
+     * Prevent the Prometheus exporter server from starting
+     * @default false
+     */
+    preventServerStart?: boolean;
+    /**
+     * **Note, this option is experimental**. Additional MetricProducers to use as a source of
+     * aggregated metric data in addition to the SDK's metric data. The resource returned by
+     * these MetricProducers is ignored; the SDK's resource will be used instead.
+     * @experimental
+     */
+    metricProducers?: MetricProducer[];
+    /**
+     * Regex pattern for defining which resource attributes will be applied
+     * as constant labels to the metrics.
+     * e.g. 'telemetry_.+' for all attributes starting with 'telemetry'.
+     * @default undefined (no resource attributes are applied)
+     */
+    withResourceConstantLabels?: RegExp;
+}
+//# sourceMappingURL=types.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/build/src/export/types.js

@@ -0,0 +1,18 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry 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
+ *
+ *      https://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

node_modules/@opentelemetry/exporter-prometheus/build/src/export/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/export/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { MetricProducer } from '@opentelemetry/sdk-metrics';\n\n/**\n * Configuration interface for prometheus exporter\n */\nexport interface ExporterConfig {\n  /**\n   * App prefix for metrics, if needed\n   *\n   * @default ''\n   * */\n  prefix?: string;\n\n  /**\n   * Append timestamp to metrics\n   * @default true\n   */\n  appendTimestamp?: boolean;\n\n  /**\n   * Endpoint the metrics should be exposed at with preceding slash\n   * @default '/metrics'\n   */\n  endpoint?: string;\n\n  /**\n   * @default undefined (all interfaces)\n   */\n  host?: string;\n\n  /**\n   * Port number for Prometheus exporter server\n   *\n   * Default registered port is 9464:\n   * https://github.com/prometheus/prometheus/wiki/Default-port-allocations\n   * @default 9464\n   */\n  port?: number;\n\n  /**\n   * Prevent the Prometheus exporter server from starting\n   * @default false\n   */\n  preventServerStart?: boolean;\n\n  /**\n   * **Note, this option is experimental**. Additional MetricProducers to use as a source of\n   * aggregated metric data in addition to the SDK's metric data. The resource returned by\n   * these MetricProducers is ignored; the SDK's resource will be used instead.\n   * @experimental\n   */\n  metricProducers?: MetricProducer[];\n\n  /**\n   * Regex pattern for defining which resource attributes will be applied\n   * as constant labels to the metrics.\n   * e.g. 'telemetry_.+' for all attributes starting with 'telemetry'.\n   * @default undefined (no resource attributes are applied)\n   */\n  withResourceConstantLabels?: RegExp;\n}\n"]}

node_modules/@opentelemetry/exporter-prometheus/build/src/index.d.ts

@@ -0,0 +1,4 @@
+export { PrometheusExporter } from './PrometheusExporter';
+export { PrometheusSerializer } from './PrometheusSerializer';
+export { ExporterConfig } from './export/types';
+//# sourceMappingURL=index.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/build/src/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry 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
+ *
+ *      https://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 });
+exports.PrometheusSerializer = exports.PrometheusExporter = void 0;
+var PrometheusExporter_1 = require("./PrometheusExporter");
+Object.defineProperty(exports, "PrometheusExporter", { enumerable: true, get: function () { return PrometheusExporter_1.PrometheusExporter; } });
+var PrometheusSerializer_1 = require("./PrometheusSerializer");
+Object.defineProperty(exports, "PrometheusSerializer", { enumerable: true, get: function () { return PrometheusSerializer_1.PrometheusSerializer; } });
+//# sourceMappingURL=index.js.map

node_modules/@opentelemetry/exporter-prometheus/build/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,2DAA0D;AAAjD,wHAAA,kBAAkB,OAAA;AAC3B,+DAA8D;AAArD,4HAAA,oBAAoB,OAAA","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport { PrometheusExporter } from './PrometheusExporter';\nexport { PrometheusSerializer } from './PrometheusSerializer';\nexport { ExporterConfig } from './export/types';\n"]}

node_modules/@opentelemetry/exporter-prometheus/build/src/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.200.0";
+//# sourceMappingURL=version.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/build/src/version.js

@@ -0,0 +1,21 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry 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
+ *
+ *      https://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 });
+exports.VERSION = void 0;
+// this is autogenerated file, see scripts/version-update.js
+exports.VERSION = '0.200.0';
+//# sourceMappingURL=version.js.map

node_modules/@opentelemetry/exporter-prometheus/build/src/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,4DAA4D;AAC/C,QAAA,OAAO,GAAG,SAAS,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// this is autogenerated file, see scripts/version-update.js\nexport const VERSION = '0.200.0';\n"]}