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

node_modules/@opentelemetry/exporter-prometheus/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

node_modules/@opentelemetry/exporter-prometheus/README.md

@@ -0,0 +1,65 @@
+# OpenTelemetry Prometheus Metric Exporter
+
+[![NPM Published Version][npm-img]][npm-url]
+[![Apache License][license-image]][license-image]
+
+**Note: This is an experimental package under active development. New releases may include breaking changes.**
+
+The OpenTelemetry Prometheus Metrics Exporter allows the user to send collected [OpenTelemetry Metrics](https://github.com/open-telemetry/opentelemetry-js/tree/main/packages/sdk-metrics) to Prometheus.
+
+[Prometheus](https://prometheus.io/) is a monitoring system that collects metrics, by scraping exposed endpoints at regular intervals, evaluating rule expressions. It can also trigger alerts if certain conditions are met. For assistance setting up Prometheus, [Click here](https://opencensus.io/codelabs/prometheus/#0) for a guided codelab.
+
+## Installation
+
+```bash
+npm install --save @opentelemetry/sdk-metrics
+npm install --save @opentelemetry/exporter-prometheus
+```
+
+## Usage
+
+Create & register the exporter on your application.
+
+```js
+const { PrometheusExporter } = require('@opentelemetry/exporter-prometheus');
+const { MeterProvider }  = require('@opentelemetry/sdk-metrics');
+
+// Add your port and startServer to the Prometheus options
+const options = {port: 9464};
+const exporter = new PrometheusExporter(options);
+
+// Creates MeterProvider and installs the exporter as a MetricReader
+const meterProvider = new MeterProvider({
+  readers: [exporter],
+});
+const meter = meterProvider.getMeter('example-prometheus');
+
+// Now, start recording data
+const counter = meter.createCounter('metric_name', {
+  description: 'Example of a counter'
+});
+counter.add(10, { pid: process.pid });
+
+// .. some other work
+```
+
+## Viewing your metrics
+
+With the above you should now be able to navigate to the Prometheus UI at: <http://localhost:9464/metrics>
+
+## Useful links
+
+- For more information on OpenTelemetry, visit: <https://opentelemetry.io/>
+- To learn more about Prometheus, visit: <https://prometheus.io/>
+- For more about OpenTelemetry JavaScript: <https://github.com/open-telemetry/opentelemetry-js>
+- For help or feedback on this project, join us in [GitHub Discussions][discussions-url]
+
+## License
+
+Apache 2.0 - See [LICENSE][license-url] for more information.
+
+[discussions-url]: https://github.com/open-telemetry/opentelemetry-js/discussions
+[license-url]: https://github.com/open-telemetry/opentelemetry-js/blob/main/LICENSE
+[license-image]: https://img.shields.io/badge/license-Apache_2.0-green.svg?style=flat
+[npm-url]: https://www.npmjs.com/package/@opentelemetry/exporter-prometheus
+[npm-img]: https://badge.fury.io/js/%40opentelemetry%2Fexporter-prometheus.svg

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"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/README.md

@@ -0,0 +1,49 @@
+# OpenTelemetry Resources Util
+
+[![NPM Published Version][npm-img]][npm-url]
+[![Apache License][license-image]][license-image]
+
+The OpenTelemetry Resource is an immutable representation of the entity producing telemetry. For example, a process producing telemetry that is running in a container on Kubernetes has a Pod name, it is in a namespace and possibly is part of a Deployment which also has a name. All three of these attributes can be included in the `Resource`.
+
+[This document][resource-semantic_conventions] defines standard attributes for resources which are accessible via [`@opentelemetry/semantic-conventions`](https://github.com/open-telemetry/opentelemetry-js/tree/main/semantic-conventions).
+
+## Installation
+
+```bash
+npm install --save @opentelemetry/resources
+```
+
+## Usage
+
+```typescript
+import { SEMRESATTRS_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+
+const resource = resourceFromAttributes({
+    [SEMRESATTRS_SERVICE_NAME]: 'api-service',
+});
+
+const anotherResource = resourceFromAttributes({
+    'service.version': '2.0.0',
+    'service.group': 'instrumentation-group'
+});
+const mergedResource = resource.merge(anotherResource);
+```
+
+## Useful links
+
+- For more information on OpenTelemetry, visit: <https://opentelemetry.io/>
+- For more about OpenTelemetry JavaScript: <https://github.com/open-telemetry/opentelemetry-js>
+- For help or feedback on this project, join us in [GitHub Discussions][discussions-url]
+
+## License
+
+Apache 2.0 - See [LICENSE][license-url] for more information.
+
+[discussions-url]: https://github.com/open-telemetry/opentelemetry-js/discussions
+[license-url]: https://github.com/open-telemetry/opentelemetry-js/blob/main/LICENSE
+[license-image]: https://img.shields.io/badge/license-Apache_2.0-green.svg?style=flat
+[npm-url]: https://www.npmjs.com/package/@opentelemetry/resources
+[npm-img]: https://badge.fury.io/js/%40opentelemetry%2Fresources.svg
+
+[resource-semantic_conventions]: https://github.com/open-telemetry/opentelemetry-specification/tree/master/specification/resource/semantic_conventions

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/Resource.d.ts

@@ -0,0 +1,37 @@
+import { Attributes } from '@opentelemetry/api';
+import { RawResourceAttribute } from './types';
+/**
+ * An interface that represents a resource. A Resource describes the entity for which signals (metrics or trace) are
+ * collected.
+ *
+ */
+export interface Resource {
+    /**
+     * Check if async attributes have resolved. This is useful to avoid awaiting
+     * waitForAsyncAttributes (which will introduce asynchronous behavior) when not necessary.
+     *
+     * @returns true if the resource "attributes" property is not yet settled to its final value
+     */
+    readonly asyncAttributesPending?: boolean;
+    /**
+     * @returns the Resource's attributes.
+     */
+    readonly attributes: Attributes;
+    /**
+     * Returns a promise that will never be rejected. Resolves when all async attributes have finished being added to
+     * this Resource's attributes. This is useful in exporters to block until resource detection
+     * has finished.
+     */
+    waitForAsyncAttributes?(): Promise<void>;
+    /**
+     * Returns a new, merged {@link Resource} by merging the current Resource
+     * with the other Resource. In case of a collision, other Resource takes
+     * precedence.
+     *
+     * @param other the Resource that will be merged with this.
+     * @returns the newly merged Resource.
+     */
+    merge(other: Resource | null): Resource;
+    getRawAttributes(): RawResourceAttribute[];
+}
+//# sourceMappingURL=Resource.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/Resource.js

@@ -0,0 +1,17 @@
+/*
+ * 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.
+ */
+export {};
+//# sourceMappingURL=Resource.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/Resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Resource.js","sourceRoot":"","sources":["../../src/Resource.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 { Attributes } from '@opentelemetry/api';\nimport { RawResourceAttribute } from './types';\n\n/**\n * An interface that represents a resource. A Resource describes the entity for which signals (metrics or trace) are\n * collected.\n *\n */\nexport interface Resource {\n  /**\n   * Check if async attributes have resolved. This is useful to avoid awaiting\n   * waitForAsyncAttributes (which will introduce asynchronous behavior) when not necessary.\n   *\n   * @returns true if the resource \"attributes\" property is not yet settled to its final value\n   */\n  readonly asyncAttributesPending?: boolean;\n\n  /**\n   * @returns the Resource's attributes.\n   */\n  readonly attributes: Attributes;\n\n  /**\n   * Returns a promise that will never be rejected. Resolves when all async attributes have finished being added to\n   * this Resource's attributes. This is useful in exporters to block until resource detection\n   * has finished.\n   */\n  waitForAsyncAttributes?(): Promise<void>;\n\n  /**\n   * Returns a new, merged {@link Resource} by merging the current Resource\n   * with the other Resource. In case of a collision, other Resource takes\n   * precedence.\n   *\n   * @param other the Resource that will be merged with this.\n   * @returns the newly merged Resource.\n   */\n  merge(other: Resource | null): Resource;\n\n  getRawAttributes(): RawResourceAttribute[];\n}\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/ResourceImpl.d.ts

@@ -0,0 +1,7 @@
+import { Resource } from './Resource';
+import { DetectedResource, DetectedResourceAttributes } from './types';
+export declare function resourceFromAttributes(attributes: DetectedResourceAttributes): Resource;
+export declare function resourceFromDetectedResource(detectedResource: DetectedResource): Resource;
+export declare function emptyResource(): Resource;
+export declare function defaultResource(): Resource;
+//# sourceMappingURL=ResourceImpl.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/ResourceImpl.js

@@ -0,0 +1,121 @@
+/*
+ * 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.
+ */
+import { diag } from '@opentelemetry/api';
+import { SDK_INFO } from '@opentelemetry/core';
+import { ATTR_SERVICE_NAME, ATTR_TELEMETRY_SDK_LANGUAGE, ATTR_TELEMETRY_SDK_NAME, ATTR_TELEMETRY_SDK_VERSION, } from '@opentelemetry/semantic-conventions';
+import { defaultServiceName } from './platform';
+import { isPromiseLike } from './utils';
+class ResourceImpl {
+    _rawAttributes;
+    _asyncAttributesPending = false;
+    _memoizedAttributes;
+    static FromAttributeList(attributes) {
+        const res = new ResourceImpl({});
+        res._rawAttributes = attributes;
+        res._asyncAttributesPending =
+            attributes.filter(([_, val]) => isPromiseLike(val)).length > 0;
+        return res;
+    }
+    constructor(
+    /**
+     * A dictionary of attributes with string keys and values that provide
+     * information about the entity as numbers, strings or booleans
+     * TODO: Consider to add check/validation on attributes.
+     */
+    resource) {
+        const attributes = resource.attributes ?? {};
+        this._rawAttributes = Object.entries(attributes).map(([k, v]) => {
+            if (isPromiseLike(v)) {
+                // side-effect
+                this._asyncAttributesPending = true;
+            }
+            return [k, v];
+        });
+    }
+    get asyncAttributesPending() {
+        return this._asyncAttributesPending;
+    }
+    async waitForAsyncAttributes() {
+        if (!this.asyncAttributesPending) {
+            return;
+        }
+        for (let i = 0; i < this._rawAttributes.length; i++) {
+            const [k, v] = this._rawAttributes[i];
+            try {
+                this._rawAttributes[i] = [k, isPromiseLike(v) ? await v : v];
+            }
+            catch (err) {
+                diag.debug("a resource's async attributes promise rejected: %s", err);
+                this._rawAttributes[i] = [k, undefined];
+            }
+        }
+        this._asyncAttributesPending = false;
+    }
+    get attributes() {
+        if (this.asyncAttributesPending) {
+            diag.error('Accessing resource attributes before async attributes settled');
+        }
+        if (this._memoizedAttributes) {
+            return this._memoizedAttributes;
+        }
+        const attrs = {};
+        for (const [k, v] of this._rawAttributes) {
+            if (isPromiseLike(v)) {
+                diag.debug(`Unsettled resource attribute ${k} skipped`);
+                continue;
+            }
+            if (v != null) {
+                attrs[k] ??= v;
+            }
+        }
+        // only memoize output if all attributes are settled
+        if (!this._asyncAttributesPending) {
+            this._memoizedAttributes = attrs;
+        }
+        return attrs;
+    }
+    getRawAttributes() {
+        return this._rawAttributes;
+    }
+    merge(resource) {
+        if (resource == null)
+            return this;
+        // Order is important
+        // Spec states incoming attributes override existing attributes
+        return ResourceImpl.FromAttributeList([
+            ...resource.getRawAttributes(),
+            ...this.getRawAttributes(),
+        ]);
+    }
+}
+export function resourceFromAttributes(attributes) {
+    return ResourceImpl.FromAttributeList(Object.entries(attributes));
+}
+export function resourceFromDetectedResource(detectedResource) {
+    return new ResourceImpl(detectedResource);
+}
+export function emptyResource() {
+    return resourceFromAttributes({});
+}
+export function defaultResource() {
+    return resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: defaultServiceName(),
+        [ATTR_TELEMETRY_SDK_LANGUAGE]: SDK_INFO[ATTR_TELEMETRY_SDK_LANGUAGE],
+        [ATTR_TELEMETRY_SDK_NAME]: SDK_INFO[ATTR_TELEMETRY_SDK_NAME],
+        [ATTR_TELEMETRY_SDK_VERSION]: SDK_INFO[ATTR_TELEMETRY_SDK_VERSION],
+    });
+}
+//# sourceMappingURL=ResourceImpl.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/config.d.ts

@@ -0,0 +1,8 @@
+import type { ResourceDetector } from './types';
+/**
+ * ResourceDetectionConfig provides an interface for configuring resource auto-detection.
+ */
+export interface ResourceDetectionConfig {
+    detectors?: Array<ResourceDetector>;
+}
+//# sourceMappingURL=config.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/config.js

@@ -0,0 +1,17 @@
+/*
+ * 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.
+ */
+export {};
+//# sourceMappingURL=config.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.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 type { ResourceDetector } from './types';\n\n/**\n * ResourceDetectionConfig provides an interface for configuring resource auto-detection.\n */\nexport interface ResourceDetectionConfig {\n  detectors?: Array<ResourceDetector>;\n}\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detect-resources.d.ts

@@ -0,0 +1,9 @@
+import { Resource } from './Resource';
+import { ResourceDetectionConfig } from './config';
+/**
+ * Runs all resource detectors and returns the results merged into a single Resource.
+ *
+ * @param config Configuration for resource detection
+ */
+export declare const detectResources: (config?: ResourceDetectionConfig) => Resource;
+//# sourceMappingURL=detect-resources.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detect-resources.js

@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+import { diag } from '@opentelemetry/api';
+import { emptyResource, resourceFromDetectedResource } from './ResourceImpl';
+/**
+ * Runs all resource detectors and returns the results merged into a single Resource.
+ *
+ * @param config Configuration for resource detection
+ */
+export const detectResources = (config = {}) => {
+    const resources = (config.detectors || []).map(d => {
+        try {
+            const resource = resourceFromDetectedResource(d.detect(config));
+            diag.debug(`${d.constructor.name} found resource.`, resource);
+            return resource;
+        }
+        catch (e) {
+            diag.debug(`${d.constructor.name} failed: ${e.message}`);
+            return emptyResource();
+        }
+    });
+    // Future check if verbose logging is enabled issue #1903
+    logResources(resources);
+    return resources.reduce((acc, resource) => acc.merge(resource), emptyResource());
+};
+/**
+ * Writes debug information about the detected resources to the logger defined in the resource detection config, if one is provided.
+ *
+ * @param resources The array of {@link Resource} that should be logged. Empty entries will be ignored.
+ */
+const logResources = (resources) => {
+    resources.forEach(resource => {
+        // Print only populated resources
+        if (Object.keys(resource.attributes).length > 0) {
+            const resourceDebugString = JSON.stringify(resource.attributes, null, 4);
+            diag.verbose(resourceDebugString);
+        }
+    });
+};
+//# sourceMappingURL=detect-resources.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detect-resources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-resources.js","sourceRoot":"","sources":["../../src/detect-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE1C,OAAO,EAAE,aAAa,EAAE,4BAA4B,EAAE,MAAM,gBAAgB,CAAC;AAG7E;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,SAAkC,EAAE,EAC1B,EAAE;IACZ,MAAM,SAAS,GAAe,CAAC,MAAM,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;QAC7D,IAAI;YACF,MAAM,QAAQ,GAAG,4BAA4B,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;YAChE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,IAAI,kBAAkB,EAAE,QAAQ,CAAC,CAAC;YAC9D,OAAO,QAAQ,CAAC;SACjB;QAAC,OAAO,CAAC,EAAE;YACV,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,IAAI,YAAY,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;YACzD,OAAO,aAAa,EAAE,CAAC;SACxB;IACH,CAAC,CAAC,CAAC;IAEH,yDAAyD;IACzD,YAAY,CAAC,SAAS,CAAC,CAAC;IAExB,OAAO,SAAS,CAAC,MAAM,CACrB,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,EACtC,aAAa,EAAE,CAChB,CAAC;AACJ,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,YAAY,GAAG,CAAC,SAA0B,EAAE,EAAE;IAClD,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;QAC3B,iCAAiC;QACjC,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;YAC/C,MAAM,mBAAmB,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YACzE,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC;SACnC;IACH,CAAC,CAAC,CAAC;AACL,CAAC,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\nimport { diag } from '@opentelemetry/api';\nimport { Resource } from './Resource';\nimport { emptyResource, resourceFromDetectedResource } from './ResourceImpl';\nimport { ResourceDetectionConfig } from './config';\n\n/**\n * Runs all resource detectors and returns the results merged into a single Resource.\n *\n * @param config Configuration for resource detection\n */\nexport const detectResources = (\n  config: ResourceDetectionConfig = {}\n): Resource => {\n  const resources: Resource[] = (config.detectors || []).map(d => {\n    try {\n      const resource = resourceFromDetectedResource(d.detect(config));\n      diag.debug(`${d.constructor.name} found resource.`, resource);\n      return resource;\n    } catch (e) {\n      diag.debug(`${d.constructor.name} failed: ${e.message}`);\n      return emptyResource();\n    }\n  });\n\n  // Future check if verbose logging is enabled issue #1903\n  logResources(resources);\n\n  return resources.reduce(\n    (acc, resource) => acc.merge(resource),\n    emptyResource()\n  );\n};\n\n/**\n * Writes debug information about the detected resources to the logger defined in the resource detection config, if one is provided.\n *\n * @param resources The array of {@link Resource} that should be logged. Empty entries will be ignored.\n */\nconst logResources = (resources: Array<Resource>) => {\n  resources.forEach(resource => {\n    // Print only populated resources\n    if (Object.keys(resource.attributes).length > 0) {\n      const resourceDebugString = JSON.stringify(resource.attributes, null, 4);\n      diag.verbose(resourceDebugString);\n    }\n  });\n};\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/EnvDetector.d.ts

@@ -0,0 +1,56 @@
+import { ResourceDetectionConfig } from '../config';
+import { DetectedResource, ResourceDetector } from '../types';
+/**
+ * EnvDetector can be used to detect the presence of and create a Resource
+ * from the OTEL_RESOURCE_ATTRIBUTES environment variable.
+ */
+declare class EnvDetector implements ResourceDetector {
+    private readonly _MAX_LENGTH;
+    private readonly _COMMA_SEPARATOR;
+    private readonly _LABEL_KEY_VALUE_SPLITTER;
+    private readonly _ERROR_MESSAGE_INVALID_CHARS;
+    private readonly _ERROR_MESSAGE_INVALID_VALUE;
+    /**
+     * Returns a {@link Resource} populated with attributes from the
+     * OTEL_RESOURCE_ATTRIBUTES environment variable. Note this is an async
+     * function to conform to the Detector interface.
+     *
+     * @param config The resource detection config
+     */
+    detect(_config?: ResourceDetectionConfig): DetectedResource;
+    /**
+     * Creates an attribute map from the OTEL_RESOURCE_ATTRIBUTES environment
+     * variable.
+     *
+     * OTEL_RESOURCE_ATTRIBUTES: A comma-separated list of attributes describing
+     * the source in more detail, e.g. “key1=val1,key2=val2”. Domain names and
+     * paths are accepted as attribute keys. Values may be quoted or unquoted in
+     * general. If a value contains whitespace, =, or " characters, it must
+     * always be quoted.
+     *
+     * @param rawEnvAttributes The resource attributes as a comma-separated list
+     * of key/value pairs.
+     * @returns The sanitized resource attributes.
+     */
+    private _parseResourceAttributes;
+    /**
+     * Determines whether the given String is a valid printable ASCII string with
+     * a length not exceed _MAX_LENGTH characters.
+     *
+     * @param str The String to be validated.
+     * @returns Whether the String is valid.
+     */
+    private _isValid;
+    private _isBaggageOctetString;
+    /**
+     * Determines whether the given String is a valid printable ASCII string with
+     * a length greater than 0 and not exceed _MAX_LENGTH characters.
+     *
+     * @param str The String to be validated.
+     * @returns Whether the String is valid and not empty.
+     */
+    private _isValidAndNotEmpty;
+}
+export declare const envDetector: EnvDetector;
+export {};
+//# sourceMappingURL=EnvDetector.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/EnvDetector.js

@@ -0,0 +1,131 @@
+/*
+ * 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.
+ */
+import { diag } from '@opentelemetry/api';
+import { SEMRESATTRS_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+import { getStringFromEnv } from '@opentelemetry/core';
+/**
+ * EnvDetector can be used to detect the presence of and create a Resource
+ * from the OTEL_RESOURCE_ATTRIBUTES environment variable.
+ */
+class EnvDetector {
+    // Type, attribute keys, and attribute values should not exceed 256 characters.
+    _MAX_LENGTH = 255;
+    // OTEL_RESOURCE_ATTRIBUTES is a comma-separated list of attributes.
+    _COMMA_SEPARATOR = ',';
+    // OTEL_RESOURCE_ATTRIBUTES contains key value pair separated by '='.
+    _LABEL_KEY_VALUE_SPLITTER = '=';
+    _ERROR_MESSAGE_INVALID_CHARS = 'should be a ASCII string with a length greater than 0 and not exceed ' +
+        this._MAX_LENGTH +
+        ' characters.';
+    _ERROR_MESSAGE_INVALID_VALUE = 'should be a ASCII string with a length not exceed ' +
+        this._MAX_LENGTH +
+        ' characters.';
+    /**
+     * Returns a {@link Resource} populated with attributes from the
+     * OTEL_RESOURCE_ATTRIBUTES environment variable. Note this is an async
+     * function to conform to the Detector interface.
+     *
+     * @param config The resource detection config
+     */
+    detect(_config) {
+        const attributes = {};
+        const rawAttributes = getStringFromEnv('OTEL_RESOURCE_ATTRIBUTES');
+        const serviceName = getStringFromEnv('OTEL_SERVICE_NAME');
+        if (rawAttributes) {
+            try {
+                const parsedAttributes = this._parseResourceAttributes(rawAttributes);
+                Object.assign(attributes, parsedAttributes);
+            }
+            catch (e) {
+                diag.debug(`EnvDetector failed: ${e.message}`);
+            }
+        }
+        if (serviceName) {
+            attributes[SEMRESATTRS_SERVICE_NAME] = serviceName;
+        }
+        return { attributes };
+    }
+    /**
+     * Creates an attribute map from the OTEL_RESOURCE_ATTRIBUTES environment
+     * variable.
+     *
+     * OTEL_RESOURCE_ATTRIBUTES: A comma-separated list of attributes describing
+     * the source in more detail, e.g. “key1=val1,key2=val2”. Domain names and
+     * paths are accepted as attribute keys. Values may be quoted or unquoted in
+     * general. If a value contains whitespace, =, or " characters, it must
+     * always be quoted.
+     *
+     * @param rawEnvAttributes The resource attributes as a comma-separated list
+     * of key/value pairs.
+     * @returns The sanitized resource attributes.
+     */
+    _parseResourceAttributes(rawEnvAttributes) {
+        if (!rawEnvAttributes)
+            return {};
+        const attributes = {};
+        const rawAttributes = rawEnvAttributes.split(this._COMMA_SEPARATOR, -1);
+        for (const rawAttribute of rawAttributes) {
+            const keyValuePair = rawAttribute.split(this._LABEL_KEY_VALUE_SPLITTER, -1);
+            if (keyValuePair.length !== 2) {
+                continue;
+            }
+            let [key, value] = keyValuePair;
+            // Leading and trailing whitespaces are trimmed.
+            key = key.trim();
+            value = value.trim().split(/^"|"$/).join('');
+            if (!this._isValidAndNotEmpty(key)) {
+                throw new Error(`Attribute key ${this._ERROR_MESSAGE_INVALID_CHARS}`);
+            }
+            if (!this._isValid(value)) {
+                throw new Error(`Attribute value ${this._ERROR_MESSAGE_INVALID_VALUE}`);
+            }
+            attributes[key] = decodeURIComponent(value);
+        }
+        return attributes;
+    }
+    /**
+     * Determines whether the given String is a valid printable ASCII string with
+     * a length not exceed _MAX_LENGTH characters.
+     *
+     * @param str The String to be validated.
+     * @returns Whether the String is valid.
+     */
+    _isValid(name) {
+        return name.length <= this._MAX_LENGTH && this._isBaggageOctetString(name);
+    }
+    // https://www.w3.org/TR/baggage/#definition
+    _isBaggageOctetString(str) {
+        for (let i = 0; i < str.length; i++) {
+            const ch = str.charCodeAt(i);
+            if (ch < 0x21 || ch === 0x2c || ch === 0x3b || ch === 0x5c || ch > 0x7e) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Determines whether the given String is a valid printable ASCII string with
+     * a length greater than 0 and not exceed _MAX_LENGTH characters.
+     *
+     * @param str The String to be validated.
+     * @returns Whether the String is valid and not empty.
+     */
+    _isValidAndNotEmpty(str) {
+        return str.length > 0 && this._isValid(str);
+    }
+}
+export const envDetector = new EnvDetector();
+//# sourceMappingURL=EnvDetector.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/NoopDetector.d.ts

@@ -0,0 +1,6 @@
+import { DetectedResource, ResourceDetector } from '../types';
+export declare class NoopDetector implements ResourceDetector {
+    detect(): DetectedResource;
+}
+export declare const noopDetector: NoopDetector;
+//# sourceMappingURL=NoopDetector.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/NoopDetector.js

@@ -0,0 +1,24 @@
+/*
+ * 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.
+ */
+export class NoopDetector {
+    detect() {
+        return {
+            attributes: {},
+        };
+    }
+}
+export const noopDetector = new NoopDetector();
+//# sourceMappingURL=NoopDetector.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/NoopDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NoopDetector.js","sourceRoot":"","sources":["../../../src/detectors/NoopDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,MAAM,OAAO,YAAY;IACvB,MAAM;QACJ,OAAO;YACL,UAAU,EAAE,EAAE;SACf,CAAC;IACJ,CAAC;CACF;AAED,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,YAAY,EAAE,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\nimport { DetectedResource, ResourceDetector } from '../types';\n\nexport class NoopDetector implements ResourceDetector {\n  detect(): DetectedResource {\n    return {\n      attributes: {},\n    };\n  }\n}\n\nexport const noopDetector = new NoopDetector();\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/index.d.ts

@@ -0,0 +1,4 @@
+export { envDetector } from './EnvDetector';
+export { hostDetector, osDetector, processDetector, serviceInstanceIdDetector, } from './platform';
+export { noopDetector } from './NoopDetector';
+//# sourceMappingURL=index.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/index.js

@@ -0,0 +1,19 @@
+/*
+ * 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.
+ */
+export { envDetector } from './EnvDetector';
+export { hostDetector, osDetector, processDetector, serviceInstanceIdDetector, } from './platform';
+export { noopDetector } from './NoopDetector';
+//# sourceMappingURL=index.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/detectors/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EACL,YAAY,EACZ,UAAU,EACV,eAAe,EACf,yBAAyB,GAC1B,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,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\nexport { envDetector } from './EnvDetector';\nexport {\n  hostDetector,\n  osDetector,\n  processDetector,\n  serviceInstanceIdDetector,\n} from './platform';\nexport { noopDetector } from './NoopDetector';\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/HostDetector.d.ts

@@ -0,0 +1,2 @@
+export declare const hostDetector: import("../../NoopDetector").NoopDetector;
+//# sourceMappingURL=HostDetector.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/HostDetector.js

@@ -0,0 +1,18 @@
+/*
+ * 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.
+ */
+import { noopDetector } from '../../NoopDetector';
+export const hostDetector = noopDetector;
+//# sourceMappingURL=HostDetector.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/HostDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HostDetector.js","sourceRoot":"","sources":["../../../../../src/detectors/platform/browser/HostDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,CAAC,MAAM,YAAY,GAAG,YAAY,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\nimport { noopDetector } from '../../NoopDetector';\n\nexport const hostDetector = noopDetector;\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/OSDetector.d.ts

@@ -0,0 +1,2 @@
+export declare const osDetector: import("../../NoopDetector").NoopDetector;
+//# sourceMappingURL=OSDetector.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/OSDetector.js

@@ -0,0 +1,18 @@
+/*
+ * 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.
+ */
+import { noopDetector } from '../../NoopDetector';
+export const osDetector = noopDetector;
+//# sourceMappingURL=OSDetector.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/OSDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OSDetector.js","sourceRoot":"","sources":["../../../../../src/detectors/platform/browser/OSDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,CAAC,MAAM,UAAU,GAAG,YAAY,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\nimport { noopDetector } from '../../NoopDetector';\n\nexport const osDetector = noopDetector;\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/ProcessDetector.d.ts

@@ -0,0 +1,2 @@
+export declare const processDetector: import("../../NoopDetector").NoopDetector;
+//# sourceMappingURL=ProcessDetector.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/ProcessDetector.js

@@ -0,0 +1,18 @@
+/*
+ * 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.
+ */
+import { noopDetector } from '../../NoopDetector';
+export const processDetector = noopDetector;
+//# sourceMappingURL=ProcessDetector.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/ProcessDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessDetector.js","sourceRoot":"","sources":["../../../../../src/detectors/platform/browser/ProcessDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,CAAC,MAAM,eAAe,GAAG,YAAY,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\nimport { noopDetector } from '../../NoopDetector';\n\nexport const processDetector = noopDetector;\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/ServiceInstanceIdDetector.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @experimental
+ */
+export declare const serviceInstanceIdDetector: import("../../NoopDetector").NoopDetector;
+//# sourceMappingURL=ServiceInstanceIdDetector.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/ServiceInstanceIdDetector.js

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+import { noopDetector } from '../../NoopDetector';
+/**
+ * @experimental
+ */
+export const serviceInstanceIdDetector = noopDetector;
+//# sourceMappingURL=ServiceInstanceIdDetector.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/ServiceInstanceIdDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceInstanceIdDetector.js","sourceRoot":"","sources":["../../../../../src/detectors/platform/browser/ServiceInstanceIdDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;GAEG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,YAAY,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\nimport { noopDetector } from '../../NoopDetector';\n\n/**\n * @experimental\n */\nexport const serviceInstanceIdDetector = noopDetector;\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/index.d.ts

@@ -0,0 +1,5 @@
+export { hostDetector } from './HostDetector';
+export { osDetector } from './OSDetector';
+export { processDetector } from './ProcessDetector';
+export { serviceInstanceIdDetector } from './ServiceInstanceIdDetector';
+//# sourceMappingURL=index.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/index.js

@@ -0,0 +1,20 @@
+/*
+ * 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.
+ */
+export { hostDetector } from './HostDetector';
+export { osDetector } from './OSDetector';
+export { processDetector } from './ProcessDetector';
+export { serviceInstanceIdDetector } from './ServiceInstanceIdDetector';
+//# sourceMappingURL=index.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/browser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/detectors/platform/browser/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,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\nexport { hostDetector } from './HostDetector';\nexport { osDetector } from './OSDetector';\nexport { processDetector } from './ProcessDetector';\nexport { serviceInstanceIdDetector } from './ServiceInstanceIdDetector';\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/index.d.ts

@@ -0,0 +1,2 @@
+export { hostDetector, osDetector, processDetector, serviceInstanceIdDetector, } from './node';
+//# sourceMappingURL=index.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/index.js

@@ -0,0 +1,17 @@
+/*
+ * 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.
+ */
+export { hostDetector, osDetector, processDetector, serviceInstanceIdDetector, } from './node';
+//# sourceMappingURL=index.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/detectors/platform/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EACL,YAAY,EACZ,UAAU,EACV,eAAe,EACf,yBAAyB,GAC1B,MAAM,QAAQ,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 */\nexport {\n  hostDetector,\n  osDetector,\n  processDetector,\n  serviceInstanceIdDetector,\n} from './node';\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/HostDetector.d.ts

@@ -0,0 +1,12 @@
+import { ResourceDetectionConfig } from '../../../config';
+import { DetectedResource, ResourceDetector } from '../../../types';
+/**
+ * HostDetector detects the resources related to the host current process is
+ * running on. Currently only non-cloud-based attributes are included.
+ */
+declare class HostDetector implements ResourceDetector {
+    detect(_config?: ResourceDetectionConfig): DetectedResource;
+}
+export declare const hostDetector: HostDetector;
+export {};
+//# sourceMappingURL=HostDetector.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/HostDetector.js

@@ -0,0 +1,35 @@
+/*
+ * 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.
+ */
+import { SEMRESATTRS_HOST_ARCH, SEMRESATTRS_HOST_ID, SEMRESATTRS_HOST_NAME, } from '@opentelemetry/semantic-conventions';
+import { arch, hostname } from 'os';
+import { getMachineId } from './machine-id/getMachineId';
+import { normalizeArch } from './utils';
+/**
+ * HostDetector detects the resources related to the host current process is
+ * running on. Currently only non-cloud-based attributes are included.
+ */
+class HostDetector {
+    detect(_config) {
+        const attributes = {
+            [SEMRESATTRS_HOST_NAME]: hostname(),
+            [SEMRESATTRS_HOST_ARCH]: normalizeArch(arch()),
+            [SEMRESATTRS_HOST_ID]: getMachineId(),
+        };
+        return { attributes };
+    }
+}
+export const hostDetector = new HostDetector();
+//# sourceMappingURL=HostDetector.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/HostDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HostDetector.js","sourceRoot":"","sources":["../../../../../src/detectors/platform/node/HostDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AAOpC,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC;;;GAGG;AACH,MAAM,YAAY;IAChB,MAAM,CAAC,OAAiC;QACtC,MAAM,UAAU,GAA+B;YAC7C,CAAC,qBAAqB,CAAC,EAAE,QAAQ,EAAE;YACnC,CAAC,qBAAqB,CAAC,EAAE,aAAa,CAAC,IAAI,EAAE,CAAC;YAC9C,CAAC,mBAAmB,CAAC,EAAE,YAAY,EAAE;SACtC,CAAC;QAEF,OAAO,EAAE,UAAU,EAAE,CAAC;IACxB,CAAC;CACF;AAED,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,YAAY,EAAE,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\nimport {\n  SEMRESATTRS_HOST_ARCH,\n  SEMRESATTRS_HOST_ID,\n  SEMRESATTRS_HOST_NAME,\n} from '@opentelemetry/semantic-conventions';\nimport { arch, hostname } from 'os';\nimport { ResourceDetectionConfig } from '../../../config';\nimport {\n  DetectedResource,\n  DetectedResourceAttributes,\n  ResourceDetector,\n} from '../../../types';\nimport { getMachineId } from './machine-id/getMachineId';\nimport { normalizeArch } from './utils';\n\n/**\n * HostDetector detects the resources related to the host current process is\n * running on. Currently only non-cloud-based attributes are included.\n */\nclass HostDetector implements ResourceDetector {\n  detect(_config?: ResourceDetectionConfig): DetectedResource {\n    const attributes: DetectedResourceAttributes = {\n      [SEMRESATTRS_HOST_NAME]: hostname(),\n      [SEMRESATTRS_HOST_ARCH]: normalizeArch(arch()),\n      [SEMRESATTRS_HOST_ID]: getMachineId(),\n    };\n\n    return { attributes };\n  }\n}\n\nexport const hostDetector = new HostDetector();\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/OSDetector.d.ts

@@ -0,0 +1,12 @@
+import { ResourceDetectionConfig } from '../../../config';
+import { DetectedResource, ResourceDetector } from '../../../types';
+/**
+ * OSDetector detects the resources related to the operating system (OS) on
+ * which the process represented by this resource is running.
+ */
+declare class OSDetector implements ResourceDetector {
+    detect(_config?: ResourceDetectionConfig): DetectedResource;
+}
+export declare const osDetector: OSDetector;
+export {};
+//# sourceMappingURL=OSDetector.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/OSDetector.js

@@ -0,0 +1,33 @@
+/*
+ * 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.
+ */
+import { SEMRESATTRS_OS_TYPE, SEMRESATTRS_OS_VERSION, } from '@opentelemetry/semantic-conventions';
+import { platform, release } from 'os';
+import { normalizeType } from './utils';
+/**
+ * OSDetector detects the resources related to the operating system (OS) on
+ * which the process represented by this resource is running.
+ */
+class OSDetector {
+    detect(_config) {
+        const attributes = {
+            [SEMRESATTRS_OS_TYPE]: normalizeType(platform()),
+            [SEMRESATTRS_OS_VERSION]: release(),
+        };
+        return { attributes };
+    }
+}
+export const osDetector = new OSDetector();
+//# sourceMappingURL=OSDetector.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/OSDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OSDetector.js","sourceRoot":"","sources":["../../../../../src/detectors/platform/node/OSDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EACL,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAGvC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC;;;GAGG;AACH,MAAM,UAAU;IACd,MAAM,CAAC,OAAiC;QACtC,MAAM,UAAU,GAAe;YAC7B,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC,QAAQ,EAAE,CAAC;YAChD,CAAC,sBAAsB,CAAC,EAAE,OAAO,EAAE;SACpC,CAAC;QACF,OAAO,EAAE,UAAU,EAAE,CAAC;IACxB,CAAC;CACF;AAED,MAAM,CAAC,MAAM,UAAU,GAAG,IAAI,UAAU,EAAE,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\nimport { Attributes } from '@opentelemetry/api';\nimport {\n  SEMRESATTRS_OS_TYPE,\n  SEMRESATTRS_OS_VERSION,\n} from '@opentelemetry/semantic-conventions';\nimport { platform, release } from 'os';\nimport { ResourceDetectionConfig } from '../../../config';\nimport { DetectedResource, ResourceDetector } from '../../../types';\nimport { normalizeType } from './utils';\n\n/**\n * OSDetector detects the resources related to the operating system (OS) on\n * which the process represented by this resource is running.\n */\nclass OSDetector implements ResourceDetector {\n  detect(_config?: ResourceDetectionConfig): DetectedResource {\n    const attributes: Attributes = {\n      [SEMRESATTRS_OS_TYPE]: normalizeType(platform()),\n      [SEMRESATTRS_OS_VERSION]: release(),\n    };\n    return { attributes };\n  }\n}\n\nexport const osDetector = new OSDetector();\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/ProcessDetector.d.ts

@@ -0,0 +1,12 @@
+import { ResourceDetectionConfig } from '../../../config';
+import { DetectedResource, ResourceDetector } from '../../../types';
+/**
+ * ProcessDetector will be used to detect the resources related current process running
+ * and being instrumented from the NodeJS Process module.
+ */
+declare class ProcessDetector implements ResourceDetector {
+    detect(_config?: ResourceDetectionConfig): DetectedResource;
+}
+export declare const processDetector: ProcessDetector;
+export {};
+//# sourceMappingURL=ProcessDetector.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/ProcessDetector.js

@@ -0,0 +1,52 @@
+/*
+ * 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.
+ */
+import { diag } from '@opentelemetry/api';
+import { SEMRESATTRS_PROCESS_COMMAND, SEMRESATTRS_PROCESS_COMMAND_ARGS, SEMRESATTRS_PROCESS_EXECUTABLE_NAME, SEMRESATTRS_PROCESS_EXECUTABLE_PATH, SEMRESATTRS_PROCESS_OWNER, SEMRESATTRS_PROCESS_PID, SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION, SEMRESATTRS_PROCESS_RUNTIME_NAME, SEMRESATTRS_PROCESS_RUNTIME_VERSION, } from '@opentelemetry/semantic-conventions';
+import * as os from 'os';
+/**
+ * ProcessDetector will be used to detect the resources related current process running
+ * and being instrumented from the NodeJS Process module.
+ */
+class ProcessDetector {
+    detect(_config) {
+        const attributes = {
+            [SEMRESATTRS_PROCESS_PID]: process.pid,
+            [SEMRESATTRS_PROCESS_EXECUTABLE_NAME]: process.title,
+            [SEMRESATTRS_PROCESS_EXECUTABLE_PATH]: process.execPath,
+            [SEMRESATTRS_PROCESS_COMMAND_ARGS]: [
+                process.argv[0],
+                ...process.execArgv,
+                ...process.argv.slice(1),
+            ],
+            [SEMRESATTRS_PROCESS_RUNTIME_VERSION]: process.versions.node,
+            [SEMRESATTRS_PROCESS_RUNTIME_NAME]: 'nodejs',
+            [SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION]: 'Node.js',
+        };
+        if (process.argv.length > 1) {
+            attributes[SEMRESATTRS_PROCESS_COMMAND] = process.argv[1];
+        }
+        try {
+            const userInfo = os.userInfo();
+            attributes[SEMRESATTRS_PROCESS_OWNER] = userInfo.username;
+        }
+        catch (e) {
+            diag.debug(`error obtaining process owner: ${e}`);
+        }
+        return { attributes };
+    }
+}
+export const processDetector = new ProcessDetector();
+//# sourceMappingURL=ProcessDetector.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/ProcessDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProcessDetector.js","sourceRoot":"","sources":["../../../../../src/detectors/platform/node/ProcessDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAc,IAAI,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EACL,2BAA2B,EAC3B,gCAAgC,EAChC,mCAAmC,EACnC,mCAAmC,EACnC,yBAAyB,EACzB,uBAAuB,EACvB,uCAAuC,EACvC,gCAAgC,EAChC,mCAAmC,GACpC,MAAM,qCAAqC,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AAIzB;;;GAGG;AACH,MAAM,eAAe;IACnB,MAAM,CAAC,OAAiC;QACtC,MAAM,UAAU,GAAe;YAC7B,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAC,GAAG;YACtC,CAAC,mCAAmC,CAAC,EAAE,OAAO,CAAC,KAAK;YACpD,CAAC,mCAAmC,CAAC,EAAE,OAAO,CAAC,QAAQ;YACvD,CAAC,gCAAgC,CAAC,EAAE;gBAClC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;gBACf,GAAG,OAAO,CAAC,QAAQ;gBACnB,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;aACzB;YACD,CAAC,mCAAmC,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,IAAI;YAC5D,CAAC,gCAAgC,CAAC,EAAE,QAAQ;YAC5C,CAAC,uCAAuC,CAAC,EAAE,SAAS;SACrD,CAAC;QAEF,IAAI,OAAO,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;YAC3B,UAAU,CAAC,2BAA2B,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SAC3D;QAED,IAAI;YACF,MAAM,QAAQ,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC;YAC/B,UAAU,CAAC,yBAAyB,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC;SAC3D;QAAC,OAAO,CAAC,EAAE;YACV,IAAI,CAAC,KAAK,CAAC,kCAAkC,CAAC,EAAE,CAAC,CAAC;SACnD;QAED,OAAO,EAAE,UAAU,EAAE,CAAC;IACxB,CAAC;CACF;AAED,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,eAAe,EAAE,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\nimport { Attributes, diag } from '@opentelemetry/api';\nimport {\n  SEMRESATTRS_PROCESS_COMMAND,\n  SEMRESATTRS_PROCESS_COMMAND_ARGS,\n  SEMRESATTRS_PROCESS_EXECUTABLE_NAME,\n  SEMRESATTRS_PROCESS_EXECUTABLE_PATH,\n  SEMRESATTRS_PROCESS_OWNER,\n  SEMRESATTRS_PROCESS_PID,\n  SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION,\n  SEMRESATTRS_PROCESS_RUNTIME_NAME,\n  SEMRESATTRS_PROCESS_RUNTIME_VERSION,\n} from '@opentelemetry/semantic-conventions';\nimport * as os from 'os';\nimport { ResourceDetectionConfig } from '../../../config';\nimport { DetectedResource, ResourceDetector } from '../../../types';\n\n/**\n * ProcessDetector will be used to detect the resources related current process running\n * and being instrumented from the NodeJS Process module.\n */\nclass ProcessDetector implements ResourceDetector {\n  detect(_config?: ResourceDetectionConfig): DetectedResource {\n    const attributes: Attributes = {\n      [SEMRESATTRS_PROCESS_PID]: process.pid,\n      [SEMRESATTRS_PROCESS_EXECUTABLE_NAME]: process.title,\n      [SEMRESATTRS_PROCESS_EXECUTABLE_PATH]: process.execPath,\n      [SEMRESATTRS_PROCESS_COMMAND_ARGS]: [\n        process.argv[0],\n        ...process.execArgv,\n        ...process.argv.slice(1),\n      ],\n      [SEMRESATTRS_PROCESS_RUNTIME_VERSION]: process.versions.node,\n      [SEMRESATTRS_PROCESS_RUNTIME_NAME]: 'nodejs',\n      [SEMRESATTRS_PROCESS_RUNTIME_DESCRIPTION]: 'Node.js',\n    };\n\n    if (process.argv.length > 1) {\n      attributes[SEMRESATTRS_PROCESS_COMMAND] = process.argv[1];\n    }\n\n    try {\n      const userInfo = os.userInfo();\n      attributes[SEMRESATTRS_PROCESS_OWNER] = userInfo.username;\n    } catch (e) {\n      diag.debug(`error obtaining process owner: ${e}`);\n    }\n\n    return { attributes };\n  }\n}\n\nexport const processDetector = new ProcessDetector();\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/ServiceInstanceIdDetector.d.ts

@@ -0,0 +1,14 @@
+import { ResourceDetectionConfig } from '../../../config';
+import { DetectedResource, ResourceDetector } from '../../../types';
+/**
+ * ServiceInstanceIdDetector detects the resources related to the service instance ID.
+ */
+declare class ServiceInstanceIdDetector implements ResourceDetector {
+    detect(_config?: ResourceDetectionConfig): DetectedResource;
+}
+/**
+ * @experimental
+ */
+export declare const serviceInstanceIdDetector: ServiceInstanceIdDetector;
+export {};
+//# sourceMappingURL=ServiceInstanceIdDetector.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/ServiceInstanceIdDetector.js

@@ -0,0 +1,34 @@
+/*
+ * 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.
+ */
+import { SEMRESATTRS_SERVICE_INSTANCE_ID } from '@opentelemetry/semantic-conventions';
+import { randomUUID } from 'crypto';
+/**
+ * ServiceInstanceIdDetector detects the resources related to the service instance ID.
+ */
+class ServiceInstanceIdDetector {
+    detect(_config) {
+        return {
+            attributes: {
+                [SEMRESATTRS_SERVICE_INSTANCE_ID]: randomUUID(),
+            },
+        };
+    }
+}
+/**
+ * @experimental
+ */
+export const serviceInstanceIdDetector = new ServiceInstanceIdDetector();
+//# sourceMappingURL=ServiceInstanceIdDetector.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/ServiceInstanceIdDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceInstanceIdDetector.js","sourceRoot":"","sources":["../../../../../src/detectors/platform/node/ServiceInstanceIdDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,+BAA+B,EAAE,MAAM,qCAAqC,CAAC;AACtF,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAIpC;;GAEG;AACH,MAAM,yBAAyB;IAC7B,MAAM,CAAC,OAAiC;QACtC,OAAO;YACL,UAAU,EAAE;gBACV,CAAC,+BAA+B,CAAC,EAAE,UAAU,EAAE;aAChD;SACF,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,IAAI,yBAAyB,EAAE,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\nimport { SEMRESATTRS_SERVICE_INSTANCE_ID } from '@opentelemetry/semantic-conventions';\nimport { randomUUID } from 'crypto';\nimport { ResourceDetectionConfig } from '../../../config';\nimport { DetectedResource, ResourceDetector } from '../../../types';\n\n/**\n * ServiceInstanceIdDetector detects the resources related to the service instance ID.\n */\nclass ServiceInstanceIdDetector implements ResourceDetector {\n  detect(_config?: ResourceDetectionConfig): DetectedResource {\n    return {\n      attributes: {\n        [SEMRESATTRS_SERVICE_INSTANCE_ID]: randomUUID(),\n      },\n    };\n  }\n}\n\n/**\n * @experimental\n */\nexport const serviceInstanceIdDetector = new ServiceInstanceIdDetector();\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/index.d.ts

@@ -0,0 +1,5 @@
+export { hostDetector } from './HostDetector';
+export { osDetector } from './OSDetector';
+export { processDetector } from './ProcessDetector';
+export { serviceInstanceIdDetector } from './ServiceInstanceIdDetector';
+//# sourceMappingURL=index.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/index.js

@@ -0,0 +1,20 @@
+/*
+ * 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.
+ */
+export { hostDetector } from './HostDetector';
+export { osDetector } from './OSDetector';
+export { processDetector } from './ProcessDetector';
+export { serviceInstanceIdDetector } from './ServiceInstanceIdDetector';
+//# sourceMappingURL=index.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/detectors/platform/node/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,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\nexport { hostDetector } from './HostDetector';\nexport { osDetector } from './OSDetector';\nexport { processDetector } from './ProcessDetector';\nexport { serviceInstanceIdDetector } from './ServiceInstanceIdDetector';\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/execAsync.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import * as child_process from 'child_process';
+export declare const execAsync: typeof child_process.exec.__promisify__;
+//# sourceMappingURL=execAsync.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/execAsync.js

@@ -0,0 +1,19 @@
+/*
+ * 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.
+ */
+import * as child_process from 'child_process';
+import * as util from 'util';
+export const execAsync = util.promisify(child_process.exec);
+//# sourceMappingURL=execAsync.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/execAsync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execAsync.js","sourceRoot":"","sources":["../../../../../../src/detectors/platform/node/machine-id/execAsync.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,aAAa,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,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\nimport * as child_process from 'child_process';\nimport * as util from 'util';\n\nexport const execAsync = util.promisify(child_process.exec);\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-bsd.d.ts

@@ -0,0 +1,2 @@
+export declare function getMachineId(): Promise<string | undefined>;
+//# sourceMappingURL=getMachineId-bsd.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-bsd.js

@@ -0,0 +1,36 @@
+/*
+ * 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.
+ */
+import { promises as fs } from 'fs';
+import { execAsync } from './execAsync';
+import { diag } from '@opentelemetry/api';
+export async function getMachineId() {
+    try {
+        const result = await fs.readFile('/etc/hostid', { encoding: 'utf8' });
+        return result.trim();
+    }
+    catch (e) {
+        diag.debug(`error reading machine id: ${e}`);
+    }
+    try {
+        const result = await execAsync('kenv -q smbios.system.uuid');
+        return result.stdout.trim();
+    }
+    catch (e) {
+        diag.debug(`error reading machine id: ${e}`);
+    }
+    return undefined;
+}
+//# sourceMappingURL=getMachineId-bsd.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-bsd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMachineId-bsd.js","sourceRoot":"","sources":["../../../../../../src/detectors/platform/node/machine-id/getMachineId-bsd.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE1C,MAAM,CAAC,KAAK,UAAU,YAAY;IAChC,IAAI;QACF,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,aAAa,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;QACtE,OAAO,MAAM,CAAC,IAAI,EAAE,CAAC;KACtB;IAAC,OAAO,CAAC,EAAE;QACV,IAAI,CAAC,KAAK,CAAC,6BAA6B,CAAC,EAAE,CAAC,CAAC;KAC9C;IAED,IAAI;QACF,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,4BAA4B,CAAC,CAAC;QAC7D,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;KAC7B;IAAC,OAAO,CAAC,EAAE;QACV,IAAI,CAAC,KAAK,CAAC,6BAA6B,CAAC,EAAE,CAAC,CAAC;KAC9C;IAED,OAAO,SAAS,CAAC;AACnB,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\nimport { promises as fs } from 'fs';\nimport { execAsync } from './execAsync';\nimport { diag } from '@opentelemetry/api';\n\nexport async function getMachineId(): Promise<string | undefined> {\n  try {\n    const result = await fs.readFile('/etc/hostid', { encoding: 'utf8' });\n    return result.trim();\n  } catch (e) {\n    diag.debug(`error reading machine id: ${e}`);\n  }\n\n  try {\n    const result = await execAsync('kenv -q smbios.system.uuid');\n    return result.stdout.trim();\n  } catch (e) {\n    diag.debug(`error reading machine id: ${e}`);\n  }\n\n  return undefined;\n}\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-darwin.d.ts

@@ -0,0 +1,2 @@
+export declare function getMachineId(): Promise<string | undefined>;
+//# sourceMappingURL=getMachineId-darwin.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-darwin.js

@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+import { execAsync } from './execAsync';
+import { diag } from '@opentelemetry/api';
+export async function getMachineId() {
+    try {
+        const result = await execAsync('ioreg -rd1 -c "IOPlatformExpertDevice"');
+        const idLine = result.stdout
+            .split('\n')
+            .find(line => line.includes('IOPlatformUUID'));
+        if (!idLine) {
+            return undefined;
+        }
+        const parts = idLine.split('" = "');
+        if (parts.length === 2) {
+            return parts[1].slice(0, -1);
+        }
+    }
+    catch (e) {
+        diag.debug(`error reading machine id: ${e}`);
+    }
+    return undefined;
+}
+//# sourceMappingURL=getMachineId-darwin.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-darwin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMachineId-darwin.js","sourceRoot":"","sources":["../../../../../../src/detectors/platform/node/machine-id/getMachineId-darwin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE1C,MAAM,CAAC,KAAK,UAAU,YAAY;IAChC,IAAI;QACF,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,wCAAwC,CAAC,CAAC;QAEzE,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM;aACzB,KAAK,CAAC,IAAI,CAAC;aACX,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAC,CAAC;QAEjD,IAAI,CAAC,MAAM,EAAE;YACX,OAAO,SAAS,CAAC;SAClB;QAED,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YACtB,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;SAC9B;KACF;IAAC,OAAO,CAAC,EAAE;QACV,IAAI,CAAC,KAAK,CAAC,6BAA6B,CAAC,EAAE,CAAC,CAAC;KAC9C;IAED,OAAO,SAAS,CAAC;AACnB,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\nimport { execAsync } from './execAsync';\nimport { diag } from '@opentelemetry/api';\n\nexport async function getMachineId(): Promise<string | undefined> {\n  try {\n    const result = await execAsync('ioreg -rd1 -c \"IOPlatformExpertDevice\"');\n\n    const idLine = result.stdout\n      .split('\\n')\n      .find(line => line.includes('IOPlatformUUID'));\n\n    if (!idLine) {\n      return undefined;\n    }\n\n    const parts = idLine.split('\" = \"');\n    if (parts.length === 2) {\n      return parts[1].slice(0, -1);\n    }\n  } catch (e) {\n    diag.debug(`error reading machine id: ${e}`);\n  }\n\n  return undefined;\n}\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-linux.d.ts

@@ -0,0 +1,2 @@
+export declare function getMachineId(): Promise<string | undefined>;
+//# sourceMappingURL=getMachineId-linux.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-linux.js

@@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+import { promises as fs } from 'fs';
+import { diag } from '@opentelemetry/api';
+export async function getMachineId() {
+    const paths = ['/etc/machine-id', '/var/lib/dbus/machine-id'];
+    for (const path of paths) {
+        try {
+            const result = await fs.readFile(path, { encoding: 'utf8' });
+            return result.trim();
+        }
+        catch (e) {
+            diag.debug(`error reading machine id: ${e}`);
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=getMachineId-linux.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-linux.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMachineId-linux.js","sourceRoot":"","sources":["../../../../../../src/detectors/platform/node/machine-id/getMachineId-linux.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,IAAI,CAAC;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE1C,MAAM,CAAC,KAAK,UAAU,YAAY;IAChC,MAAM,KAAK,GAAG,CAAC,iBAAiB,EAAE,0BAA0B,CAAC,CAAC;IAE9D,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;QACxB,IAAI;YACF,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;YAC7D,OAAO,MAAM,CAAC,IAAI,EAAE,CAAC;SACtB;QAAC,OAAO,CAAC,EAAE;YACV,IAAI,CAAC,KAAK,CAAC,6BAA6B,CAAC,EAAE,CAAC,CAAC;SAC9C;KACF;IAED,OAAO,SAAS,CAAC;AACnB,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 */\nimport { promises as fs } from 'fs';\nimport { diag } from '@opentelemetry/api';\n\nexport async function getMachineId(): Promise<string | undefined> {\n  const paths = ['/etc/machine-id', '/var/lib/dbus/machine-id'];\n\n  for (const path of paths) {\n    try {\n      const result = await fs.readFile(path, { encoding: 'utf8' });\n      return result.trim();\n    } catch (e) {\n      diag.debug(`error reading machine id: ${e}`);\n    }\n  }\n\n  return undefined;\n}\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-unsupported.d.ts

@@ -0,0 +1,2 @@
+export declare function getMachineId(): Promise<string | undefined>;
+//# sourceMappingURL=getMachineId-unsupported.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-unsupported.js

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+import { diag } from '@opentelemetry/api';
+export async function getMachineId() {
+    diag.debug('could not read machine-id: unsupported platform');
+    return undefined;
+}
+//# sourceMappingURL=getMachineId-unsupported.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-unsupported.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMachineId-unsupported.js","sourceRoot":"","sources":["../../../../../../src/detectors/platform/node/machine-id/getMachineId-unsupported.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE1C,MAAM,CAAC,KAAK,UAAU,YAAY;IAChC,IAAI,CAAC,KAAK,CAAC,iDAAiD,CAAC,CAAC;IAC9D,OAAO,SAAS,CAAC;AACnB,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\nimport { diag } from '@opentelemetry/api';\n\nexport async function getMachineId(): Promise<string | undefined> {\n  diag.debug('could not read machine-id: unsupported platform');\n  return undefined;\n}\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-win.d.ts

@@ -0,0 +1,2 @@
+export declare function getMachineId(): Promise<string | undefined>;
+//# sourceMappingURL=getMachineId-win.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-win.js

@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+import * as process from 'process';
+import { execAsync } from './execAsync';
+import { diag } from '@opentelemetry/api';
+export async function getMachineId() {
+    const args = 'QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid';
+    let command = '%windir%\\System32\\REG.exe';
+    if (process.arch === 'ia32' && 'PROCESSOR_ARCHITEW6432' in process.env) {
+        command = '%windir%\\sysnative\\cmd.exe /c ' + command;
+    }
+    try {
+        const result = await execAsync(`${command} ${args}`);
+        const parts = result.stdout.split('REG_SZ');
+        if (parts.length === 2) {
+            return parts[1].trim();
+        }
+    }
+    catch (e) {
+        diag.debug(`error reading machine id: ${e}`);
+    }
+    return undefined;
+}
+//# sourceMappingURL=getMachineId-win.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-win.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMachineId-win.js","sourceRoot":"","sources":["../../../../../../src/detectors/platform/node/machine-id/getMachineId-win.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE1C,MAAM,CAAC,KAAK,UAAU,YAAY;IAChC,MAAM,IAAI,GACR,4EAA4E,CAAC;IAC/E,IAAI,OAAO,GAAG,6BAA6B,CAAC;IAC5C,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,IAAI,wBAAwB,IAAI,OAAO,CAAC,GAAG,EAAE;QACtE,OAAO,GAAG,kCAAkC,GAAG,OAAO,CAAC;KACxD;IAED,IAAI;QACF,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,GAAG,OAAO,IAAI,IAAI,EAAE,CAAC,CAAC;QACrD,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC5C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YACtB,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SACxB;KACF;IAAC,OAAO,CAAC,EAAE;QACV,IAAI,CAAC,KAAK,CAAC,6BAA6B,CAAC,EAAE,CAAC,CAAC;KAC9C;IAED,OAAO,SAAS,CAAC;AACnB,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\nimport * as process from 'process';\nimport { execAsync } from './execAsync';\nimport { diag } from '@opentelemetry/api';\n\nexport async function getMachineId(): Promise<string | undefined> {\n  const args =\n    'QUERY HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Microsoft\\\\Cryptography /v MachineGuid';\n  let command = '%windir%\\\\System32\\\\REG.exe';\n  if (process.arch === 'ia32' && 'PROCESSOR_ARCHITEW6432' in process.env) {\n    command = '%windir%\\\\sysnative\\\\cmd.exe /c ' + command;\n  }\n\n  try {\n    const result = await execAsync(`${command} ${args}`);\n    const parts = result.stdout.split('REG_SZ');\n    if (parts.length === 2) {\n      return parts[1].trim();\n    }\n  } catch (e) {\n    diag.debug(`error reading machine id: ${e}`);\n  }\n\n  return undefined;\n}\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId.d.ts

@@ -0,0 +1,3 @@
+declare let getMachineId: () => Promise<string | undefined>;
+export { getMachineId };
+//# sourceMappingURL=getMachineId.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId.js

@@ -0,0 +1,35 @@
+/*
+ * 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.
+ */
+import * as process from 'process';
+let getMachineId;
+switch (process.platform) {
+    case 'darwin':
+        ({ getMachineId } = require('./getMachineId-darwin'));
+        break;
+    case 'linux':
+        ({ getMachineId } = require('./getMachineId-linux'));
+        break;
+    case 'freebsd':
+        ({ getMachineId } = require('./getMachineId-bsd'));
+        break;
+    case 'win32':
+        ({ getMachineId } = require('./getMachineId-win'));
+        break;
+    default:
+        ({ getMachineId } = require('./getMachineId-unsupported'));
+}
+export { getMachineId };
+//# sourceMappingURL=getMachineId.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMachineId.js","sourceRoot":"","sources":["../../../../../../src/detectors/platform/node/machine-id/getMachineId.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAEnC,IAAI,YAA+C,CAAC;AAEpD,QAAQ,OAAO,CAAC,QAAQ,EAAE;IACxB,KAAK,QAAQ;QACX,CAAC,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC;QACtD,MAAM;IACR,KAAK,OAAO;QACV,CAAC,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC;QACrD,MAAM;IACR,KAAK,SAAS;QACZ,CAAC,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC;QACnD,MAAM;IACR,KAAK,OAAO;QACV,CAAC,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC;QACnD,MAAM;IACR;QACE,CAAC,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC,CAAC;CAC9D;AAED,OAAO,EAAE,YAAY,EAAE,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 */\nimport * as process from 'process';\n\nlet getMachineId: () => Promise<string | undefined>;\n\nswitch (process.platform) {\n  case 'darwin':\n    ({ getMachineId } = require('./getMachineId-darwin'));\n    break;\n  case 'linux':\n    ({ getMachineId } = require('./getMachineId-linux'));\n    break;\n  case 'freebsd':\n    ({ getMachineId } = require('./getMachineId-bsd'));\n    break;\n  case 'win32':\n    ({ getMachineId } = require('./getMachineId-win'));\n    break;\n  default:\n    ({ getMachineId } = require('./getMachineId-unsupported'));\n}\n\nexport { getMachineId };\n"]}

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const normalizeArch: (nodeArchString: string) => string;
+export declare const normalizeType: (nodePlatform: string) => string;
+//# sourceMappingURL=utils.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/utils.js

@@ -0,0 +1,42 @@
+/*
+ * 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.
+ */
+export const normalizeArch = (nodeArchString) => {
+    // Maps from https://nodejs.org/api/os.html#osarch to arch values in spec:
+    // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/resource/semantic_conventions/host.md
+    switch (nodeArchString) {
+        case 'arm':
+            return 'arm32';
+        case 'ppc':
+            return 'ppc32';
+        case 'x64':
+            return 'amd64';
+        default:
+            return nodeArchString;
+    }
+};
+export const normalizeType = (nodePlatform) => {
+    // Maps from https://nodejs.org/api/os.html#osplatform to arch values in spec:
+    // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/resource/semantic_conventions/os.md
+    switch (nodePlatform) {
+        case 'sunos':
+            return 'solaris';
+        case 'win32':
+            return 'windows';
+        default:
+            return nodePlatform;
+    }
+};
+//# sourceMappingURL=utils.js.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../src/detectors/platform/node/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,cAAsB,EAAU,EAAE;IAC9D,0EAA0E;IAC1E,8HAA8H;IAC9H,QAAQ,cAAc,EAAE;QACtB,KAAK,KAAK;YACR,OAAO,OAAO,CAAC;QACjB,KAAK,KAAK;YACR,OAAO,OAAO,CAAC;QACjB,KAAK,KAAK;YACR,OAAO,OAAO,CAAC;QACjB;YACE,OAAO,cAAc,CAAC;KACzB;AACH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,YAAoB,EAAU,EAAE;IAC5D,8EAA8E;IAC9E,4HAA4H;IAC5H,QAAQ,YAAY,EAAE;QACpB,KAAK,OAAO;YACV,OAAO,SAAS,CAAC;QACnB,KAAK,OAAO;YACV,OAAO,SAAS,CAAC;QACnB;YACE,OAAO,YAAY,CAAC;KACvB;AACH,CAAC,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 */\nexport const normalizeArch = (nodeArchString: string): string => {\n  // Maps from https://nodejs.org/api/os.html#osarch to arch values in spec:\n  // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/resource/semantic_conventions/host.md\n  switch (nodeArchString) {\n    case 'arm':\n      return 'arm32';\n    case 'ppc':\n      return 'ppc32';\n    case 'x64':\n      return 'amd64';\n    default:\n      return nodeArchString;\n  }\n};\n\nexport const normalizeType = (nodePlatform: string): string => {\n  // Maps from https://nodejs.org/api/os.html#osplatform to arch values in spec:\n  // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/resource/semantic_conventions/os.md\n  switch (nodePlatform) {\n    case 'sunos':\n      return 'solaris';\n    case 'win32':\n      return 'windows';\n    default:\n      return nodePlatform;\n  }\n};\n"]}

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

@@ -0,0 +1,8 @@
+export { ResourceDetectionConfig } from './config';
+export { detectResources } from './detect-resources';
+export { envDetector, hostDetector, osDetector, processDetector, serviceInstanceIdDetector, } from './detectors';
+export { Resource } from './Resource';
+export { resourceFromAttributes, defaultResource, emptyResource, } from './ResourceImpl';
+export { defaultServiceName } from './platform';
+export { ResourceDetector, DetectedResource, DetectedResourceAttributes, RawResourceAttribute, MaybePromise, } from './types';
+//# sourceMappingURL=index.d.ts.map

node_modules/@opentelemetry/exporter-prometheus/node_modules/@opentelemetry/resources/build/esm/index.js

@@ -0,0 +1,20 @@
+/*
+ * 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.
+ */
+export { detectResources } from './detect-resources';
+export { envDetector, hostDetector, osDetector, processDetector, serviceInstanceIdDetector, } from './detectors';
+export { resourceFromAttributes, defaultResource, emptyResource, } from './ResourceImpl';
+export { defaultServiceName } from './platform';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EACL,WAAW,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,yBAAyB,GAC1B,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,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\nexport { ResourceDetectionConfig } from './config';\nexport { detectResources } from './detect-resources';\nexport {\n  envDetector,\n  hostDetector,\n  osDetector,\n  processDetector,\n  serviceInstanceIdDetector,\n} from './detectors';\nexport { Resource } from './Resource';\nexport {\n  resourceFromAttributes,\n  defaultResource,\n  emptyResource,\n} from './ResourceImpl';\nexport { defaultServiceName } from './platform';\nexport {\n  ResourceDetector,\n  DetectedResource,\n  DetectedResourceAttributes,\n  RawResourceAttribute,\n  MaybePromise,\n} from './types';\n"]}