@aeolus-fleet/console 0.29.1 → 0.30.0

package/.next/standalone/node_modules/@opentelemetry/configuration/build/src/index.js

@@ -0,0 +1,14 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergePropagatorCompositeConfig = exports.mergeResourceAttributesConfig = exports.mergeHeadersConfig = exports.createConfigFactory = void 0;
+var ConfigFactory_1 = require("./ConfigFactory");
+Object.defineProperty(exports, "createConfigFactory", { enumerable: true, get: function () { return ConfigFactory_1.createConfigFactory; } });
+var FileConfigFactory_1 = require("./FileConfigFactory");
+Object.defineProperty(exports, "mergeHeadersConfig", { enumerable: true, get: function () { return FileConfigFactory_1.mergeHeadersConfig; } });
+Object.defineProperty(exports, "mergeResourceAttributesConfig", { enumerable: true, get: function () { return FileConfigFactory_1.mergeResourceAttributesConfig; } });
+Object.defineProperty(exports, "mergePropagatorCompositeConfig", { enumerable: true, get: function () { return FileConfigFactory_1.mergePropagatorCompositeConfig; } });
+//# sourceMappingURL=index.js.map

package/.next/standalone/node_modules/@opentelemetry/configuration/build/src/utils.js

@@ -0,0 +1,188 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHttpTlsConfig = exports.initializeDefaultLoggerProviderConfiguration = exports.initializeDefaultMeterProviderConfiguration = exports.initializeDefaultTracerProviderConfiguration = exports.initializeDefaultConfiguration = exports.getGrpcTlsConfig = exports.substituteEnvVars = void 0;
+const yaml = require("yaml");
+const core_1 = require("@opentelemetry/core");
+/**
+ * Handle (Environment) variable substitution per
+ * https://opentelemetry.io/docs/specs/otel/configuration/data-model/#environment-variable-substitution
+ *
+ * This changes the yaml.Document in-place.
+ * This must work with a yaml.Document, rather than a raw JS object from
+ * `yaml.parse()`, to distinguish between `foo: ${BAR}` and `foo: "${BAR}"`.
+ *
+ * Exported for testing.
+ */
+function substituteEnvVars(doc) {
+    // Visit each scalar string value in the document. These are
+    // the candidates for env var substitution.
+    yaml.visit(doc, {
+        Scalar: (key, node, _path) => {
+            if (key === 'key')
+                return; // skip mapping keys
+            if (typeof node.value !== 'string')
+                return;
+            let subbed = envVarSubst(node.value);
+            if (subbed !== node.value && node.type === yaml.Scalar.PLAIN) {
+                // "PLAIN" here is a simple YAML value (e.g. 42 in `foo: 42`).
+                // I.e., not quoted (`foo: "42"`) or in a block.
+                subbed = yamlScalarCoerce(subbed);
+            }
+            node.value = subbed;
+        },
+    });
+}
+exports.substituteEnvVars = substituteEnvVars;
+// ENV_SUBSTITUTION_RE *mostly* matches the `ENV-SUBSTITUTION` ABNF from the
+// spec with the exception of the DEFAULT-VALUE: we are using `[^\n}]*`
+// (copying the OTel Java regex) rather than a regex closer to ABNF
+// `*(VCHAR-WSP-NO-RBRACE)` (which is slightly ambiguous on what whitespace is
+// allowed in WSP).
+const ENV_SUBSTITUTION_RE = /^([a-zA-Z_][a-zA-Z0-9_]*)(?::-([^\n}]*))?$/;
+/**
+ * Do environment variable substitution for the given string value.
+ */
+function envVarSubst(s) {
+    const ESCAPE_RE = /(\$\$)/;
+    const chunks = s.split(ESCAPE_RE);
+    for (let i = 0; i < chunks.length; ++i) {
+        if (i % 2 === 1) {
+            // Odd chunks are matched escape sequences, i.e. '$$'.
+            chunks[i] = '$';
+            continue;
+        }
+        // Even chunks are processed for possible substition matches.
+        const SUBSTITUTION_REF_RE = /\$\{(?:env:)?([^}]+)\}/g;
+        let chunk = '';
+        let lastIndex = 0;
+        let match;
+        while ((match = SUBSTITUTION_REF_RE.exec(chunks[i])) !== null) {
+            chunk += chunks[i].slice(lastIndex, match.index);
+            const envMatch = ENV_SUBSTITUTION_RE.exec(match[1]);
+            if (!envMatch) {
+                // E.g.: `key: ${STRING_VALUE:?error}` test case
+                throw new Error(`parse error: invalid env var substitution: ${match[0]}`);
+            }
+            const envName = envMatch[1];
+            const defaultValue = envMatch[2] ?? '';
+            chunk += (0, core_1.getStringFromEnv)(envName) || defaultValue;
+            lastIndex = SUBSTITUTION_REF_RE.lastIndex;
+        }
+        chunk += chunks[i].slice(lastIndex);
+        chunks[i] = chunk;
+    }
+    const result = chunks.join('');
+    return result;
+}
+/**
+ * Re-interpret a string value from env var substitution as a possible
+ * YAML number, boolean, or null value.
+ *
+ * If the interpretted value is any other type, we return the original
+ * string:
+ * - sequences and  mappings may not result from env var substitution, per the spec
+ * - a re-parsed YAML string normalizes whitespace, which we do not want
+ */
+function yamlScalarCoerce(value) {
+    let coerced;
+    try {
+        coerced = yaml.parse(value, { version: '1.2' });
+    }
+    catch {
+        return value;
+    }
+    const type = typeof coerced;
+    if (coerced === null || type === 'number' || type === 'boolean') {
+        return coerced;
+    }
+    else {
+        return value;
+    }
+}
+function getGrpcTlsConfig(certificateFile, clientKeyFile, clientCertificateFile, insecure) {
+    if (certificateFile || clientKeyFile || clientCertificateFile) {
+        const tls = {};
+        if (certificateFile) {
+            tls.ca_file = certificateFile;
+        }
+        if (clientKeyFile) {
+            tls.key_file = clientKeyFile;
+        }
+        if (clientCertificateFile) {
+            tls.cert_file = clientCertificateFile;
+        }
+        if (insecure !== undefined) {
+            tls.insecure = insecure;
+        }
+        return tls;
+    }
+    return undefined;
+}
+exports.getGrpcTlsConfig = getGrpcTlsConfig;
+function initializeDefaultConfiguration() {
+    return {
+        disabled: false,
+        log_level: 'info',
+        resource: {},
+        attribute_limits: {
+            attribute_count_limit: 128,
+        },
+    };
+}
+exports.initializeDefaultConfiguration = initializeDefaultConfiguration;
+function initializeDefaultTracerProviderConfiguration() {
+    return {
+        processors: [],
+        limits: {
+            attribute_count_limit: 128,
+            event_count_limit: 128,
+            link_count_limit: 128,
+            event_attribute_count_limit: 128,
+            link_attribute_count_limit: 128,
+        },
+        sampler: {
+            parent_based: {
+                root: { always_on: null },
+            },
+        },
+    };
+}
+exports.initializeDefaultTracerProviderConfiguration = initializeDefaultTracerProviderConfiguration;
+function initializeDefaultMeterProviderConfiguration() {
+    return {
+        readers: [],
+        views: [],
+        exemplar_filter: 'trace_based',
+    };
+}
+exports.initializeDefaultMeterProviderConfiguration = initializeDefaultMeterProviderConfiguration;
+function initializeDefaultLoggerProviderConfiguration() {
+    return {
+        processors: [],
+        limits: { attribute_count_limit: 128 },
+        'logger_configurator/development': {},
+    };
+}
+exports.initializeDefaultLoggerProviderConfiguration = initializeDefaultLoggerProviderConfiguration;
+function getHttpTlsConfig(certificateFile, clientKeyFile, clientCertificateFile) {
+    if (certificateFile || clientKeyFile || clientCertificateFile) {
+        const tls = {};
+        if (certificateFile) {
+            tls.ca_file = certificateFile;
+        }
+        if (clientKeyFile) {
+            tls.key_file = clientKeyFile;
+        }
+        if (clientCertificateFile) {
+            tls.cert_file = clientCertificateFile;
+        }
+        return tls;
+    }
+    return undefined;
+}
+exports.getHttpTlsConfig = getHttpTlsConfig;
+//# sourceMappingURL=utils.js.map

package/.next/standalone/node_modules/@opentelemetry/configuration/build/src/version.js

@@ -0,0 +1,10 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// this is autogenerated file, see scripts/version-update.js
+exports.VERSION = '0.223.0';
+//# sourceMappingURL=version.js.map

package/.next/standalone/node_modules/@opentelemetry/otlp-grpc-exporter-base/build/src/configuration/convert-legacy-otlp-grpc-options.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertLegacyOtlpGrpcOptions = void 0;
+const otlp_grpc_configuration_1 = require("./otlp-grpc-configuration");
+const grpc_exporter_transport_1 = require("../grpc-exporter-transport");
+const otlp_grpc_env_configuration_1 = require("./otlp-grpc-env-configuration");
+/**
+ * @deprecated
+ * @param config
+ * @param signalIdentifier
+ */
+function convertLegacyOtlpGrpcOptions(config, signalIdentifier) {
+    // keep credentials locally in case user updates the reference on the config object
+    const userProvidedCredentials = config.credentials;
+    return (0, otlp_grpc_configuration_1.mergeOtlpGrpcConfigurationWithDefaults)({
+        url: config.url,
+        metadata: () => {
+            // metadata resolution strategy is merge, so we can return empty here, and it will not override the rest of the settings.
+            return config.metadata ?? (0, grpc_exporter_transport_1.createEmptyMetadata)();
+        },
+        compression: config.compression,
+        timeoutMillis: config.timeoutMillis,
+        concurrencyLimit: config.concurrencyLimit,
+        credentials: userProvidedCredentials != null
+            ? () => userProvidedCredentials
+            : undefined,
+        userAgent: config.userAgent,
+    }, (0, otlp_grpc_env_configuration_1.getOtlpGrpcConfigurationFromEnv)(signalIdentifier), (0, otlp_grpc_configuration_1.getOtlpGrpcDefaultConfiguration)());
+}
+exports.convertLegacyOtlpGrpcOptions = convertLegacyOtlpGrpcOptions;
+//# sourceMappingURL=convert-legacy-otlp-grpc-options.js.map

package/.next/standalone/node_modules/@opentelemetry/otlp-grpc-exporter-base/build/src/configuration/otlp-grpc-configuration.js

@@ -0,0 +1,78 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOtlpGrpcDefaultConfiguration = exports.mergeOtlpGrpcConfigurationWithDefaults = exports.validateAndNormalizeUrl = void 0;
+const otlp_exporter_base_1 = require("@opentelemetry/otlp-exporter-base");
+const grpc_exporter_transport_1 = require("../grpc-exporter-transport");
+const url_1 = require("url");
+const api_1 = require("@opentelemetry/api");
+function validateAndNormalizeUrl(url) {
+    url = url.trim();
+    const hasProtocol = url.match(/^([\w]{1,8}):\/\//);
+    if (!hasProtocol) {
+        url = `https://${url}`;
+    }
+    const target = new url_1.URL(url);
+    if (target.protocol === 'unix:') {
+        return url;
+    }
+    if (target.pathname && target.pathname !== '/') {
+        api_1.diag.warn('URL path should not be set when using grpc, the path part of the URL will be ignored.');
+    }
+    if (target.protocol !== '' && !target.protocol?.match(/^(http)s?:$/)) {
+        api_1.diag.warn('URL protocol should be http(s)://. Using http://.');
+    }
+    return target.host;
+}
+exports.validateAndNormalizeUrl = validateAndNormalizeUrl;
+function overrideMetadataEntriesIfNotPresent(metadata, additionalMetadata) {
+    for (const [key, value] of Object.entries(additionalMetadata.getMap())) {
+        // only override with env var data if the key has no values.
+        // not using Metadata.merge() as it will keep both values.
+        if (metadata.get(key).length < 1) {
+            metadata.set(key, value);
+        }
+    }
+}
+function mergeOtlpGrpcConfigurationWithDefaults(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration) {
+    const rawUrl = userProvidedConfiguration.url ??
+        fallbackConfiguration.url ??
+        defaultConfiguration.url;
+    return {
+        ...(0, otlp_exporter_base_1.mergeOtlpSharedConfigurationWithDefaults)(userProvidedConfiguration, fallbackConfiguration, defaultConfiguration),
+        metadata: () => {
+            const metadata = defaultConfiguration.metadata();
+            overrideMetadataEntriesIfNotPresent(metadata, 
+            // clone to ensure we don't modify what the user gave us in case they hold on to the returned reference
+            userProvidedConfiguration.metadata?.().clone() ?? (0, grpc_exporter_transport_1.createEmptyMetadata)());
+            overrideMetadataEntriesIfNotPresent(metadata, fallbackConfiguration.metadata?.() ?? (0, grpc_exporter_transport_1.createEmptyMetadata)());
+            return metadata;
+        },
+        url: validateAndNormalizeUrl(rawUrl),
+        credentials: userProvidedConfiguration.credentials ??
+            fallbackConfiguration.credentials?.(rawUrl) ??
+            defaultConfiguration.credentials(rawUrl),
+        userAgent: userProvidedConfiguration.userAgent,
+    };
+}
+exports.mergeOtlpGrpcConfigurationWithDefaults = mergeOtlpGrpcConfigurationWithDefaults;
+function getOtlpGrpcDefaultConfiguration() {
+    return {
+        ...(0, otlp_exporter_base_1.getSharedConfigurationDefaults)(),
+        metadata: () => (0, grpc_exporter_transport_1.createEmptyMetadata)(),
+        url: 'http://localhost:4317',
+        credentials: (url) => {
+            if (url.startsWith('http://')) {
+                return () => (0, grpc_exporter_transport_1.createInsecureCredentials)();
+            }
+            else {
+                return () => (0, grpc_exporter_transport_1.createSslCredentials)();
+            }
+        },
+    };
+}
+exports.getOtlpGrpcDefaultConfiguration = getOtlpGrpcDefaultConfiguration;
+//# sourceMappingURL=otlp-grpc-configuration.js.map

package/.next/standalone/node_modules/@opentelemetry/otlp-grpc-exporter-base/build/src/configuration/otlp-grpc-env-configuration.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOtlpGrpcConfigurationFromEnv = void 0;
+const core_1 = require("@opentelemetry/core");
+const grpc_exporter_transport_1 = require("../grpc-exporter-transport");
+const node_http_1 = require("@opentelemetry/otlp-exporter-base/node-http");
+const fs = require("fs");
+const path = require("path");
+const api_1 = require("@opentelemetry/api");
+function fallbackIfNullishOrBlank(signalSpecific, nonSignalSpecific) {
+    if (signalSpecific != null && signalSpecific !== '') {
+        return signalSpecific;
+    }
+    if (nonSignalSpecific != null && nonSignalSpecific !== '') {
+        return nonSignalSpecific;
+    }
+    return undefined;
+}
+function getMetadataFromEnv(signalIdentifier) {
+    const signalSpecificRawHeaders = process.env[`OTEL_EXPORTER_OTLP_${signalIdentifier}_HEADERS`]?.trim();
+    const nonSignalSpecificRawHeaders = process.env['OTEL_EXPORTER_OTLP_HEADERS']?.trim();
+    const signalSpecificHeaders = (0, core_1.parseKeyPairsIntoRecord)(signalSpecificRawHeaders);
+    const nonSignalSpecificHeaders = (0, core_1.parseKeyPairsIntoRecord)(nonSignalSpecificRawHeaders);
+    if (Object.keys(signalSpecificHeaders).length === 0 &&
+        Object.keys(nonSignalSpecificHeaders).length === 0) {
+        return undefined;
+    }
+    const mergeHeaders = Object.assign({}, nonSignalSpecificHeaders, signalSpecificHeaders);
+    const metadata = (0, grpc_exporter_transport_1.createEmptyMetadata)();
+    // for this to work, metadata MUST be empty - otherwise `Metadata#set()` will merge items.
+    for (const [key, value] of Object.entries(mergeHeaders)) {
+        metadata.set(key, value);
+    }
+    return metadata;
+}
+function getMetadataProviderFromEnv(signalIdentifier) {
+    const metadata = getMetadataFromEnv(signalIdentifier);
+    if (metadata == null) {
+        return undefined;
+    }
+    return () => metadata;
+}
+function getUrlFromEnv(signalIdentifier) {
+    // This does not change the string beyond trimming on purpose.
+    // Normally a user would just use a host and port for gRPC, but the OTLP Exporter specification requires us to
+    // use the raw provided endpoint to derive credential settings. Therefore, we only normalize right when
+    // we merge user-provided, env-provided and defaults together, and we have determined which credentials to use.
+    //
+    // Examples:
+    // - example.test:4317 -> use secure credentials from environment (or provided via code)
+    // - http://example.test:4317 -> use insecure credentials if nothing else is provided
+    // - https://example.test:4317 -> use secure credentials from environment (or provided via code)
+    const specificEndpoint = process.env[`OTEL_EXPORTER_OTLP_${signalIdentifier}_ENDPOINT`]?.trim();
+    const nonSpecificEndpoint = process.env['OTEL_EXPORTER_OTLP_ENDPOINT']?.trim();
+    return fallbackIfNullishOrBlank(specificEndpoint, nonSpecificEndpoint);
+}
+/**
+ * Determines whether the env var for insecure credentials is set to {@code true}.
+ *
+ * It will allow the following values as {@code true}
+ * - 'true'
+ * - 'true   '
+ * - '   true'
+ * - 'TrUE'
+ * - 'TRUE'
+ *
+ * It will not allow:
+ * - 'true false'
+ * - 'false true'
+ * - 'true!'
+ * - 'true,true'
+ * - '1'
+ * - ' '
+ *
+ * @param signalIdentifier
+ */
+function getInsecureSettingFromEnv(signalIdentifier) {
+    const signalSpecificInsecureValue = process.env[`OTEL_EXPORTER_OTLP_${signalIdentifier}_INSECURE`]
+        ?.toLowerCase()
+        .trim();
+    const nonSignalSpecificInsecureValue = process.env['OTEL_EXPORTER_OTLP_INSECURE']
+        ?.toLowerCase()
+        .trim();
+    return (fallbackIfNullishOrBlank(signalSpecificInsecureValue, nonSignalSpecificInsecureValue) === 'true');
+}
+function readFileFromEnv(signalSpecificEnvVar, nonSignalSpecificEnvVar, warningMessage) {
+    const signalSpecificPath = process.env[signalSpecificEnvVar]?.trim();
+    const nonSignalSpecificPath = process.env[nonSignalSpecificEnvVar]?.trim();
+    const filePath = fallbackIfNullishOrBlank(signalSpecificPath, nonSignalSpecificPath);
+    if (filePath != null) {
+        try {
+            return fs.readFileSync(path.resolve(process.cwd(), filePath));
+        }
+        catch {
+            api_1.diag.warn(warningMessage);
+            return undefined;
+        }
+    }
+    else {
+        return undefined;
+    }
+}
+function getClientCertificateFromEnv(signalIdentifier) {
+    return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CLIENT_CERTIFICATE`, 'OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE', 'Failed to read client certificate chain file');
+}
+function getClientKeyFromEnv(signalIdentifier) {
+    return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CLIENT_KEY`, 'OTEL_EXPORTER_OTLP_CLIENT_KEY', 'Failed to read client certificate private key file');
+}
+function getRootCertificateFromEnv(signalIdentifier) {
+    return readFileFromEnv(`OTEL_EXPORTER_OTLP_${signalIdentifier}_CERTIFICATE`, 'OTEL_EXPORTER_OTLP_CERTIFICATE', 'Failed to read root certificate file');
+}
+function getCredentialsFromEnvIgnoreInsecure(signalIdentifier) {
+    const clientKey = getClientKeyFromEnv(signalIdentifier);
+    const clientCertificate = getClientCertificateFromEnv(signalIdentifier);
+    const rootCertificate = getRootCertificateFromEnv(signalIdentifier);
+    // if the chain is not intact, @grpc/grpc-js will throw. This is fine when a user provides it in code, but env var
+    // config is not allowed to throw, so we add this safeguard and try to make the best of it here.
+    const clientChainIntact = clientKey != null && clientCertificate != null;
+    if (rootCertificate != null && !clientChainIntact) {
+        api_1.diag.warn('Client key and certificate must both be provided, but one was missing - attempting to create credentials from just the root certificate');
+        return (0, grpc_exporter_transport_1.createSslCredentials)(getRootCertificateFromEnv(signalIdentifier));
+    }
+    return (0, grpc_exporter_transport_1.createSslCredentials)(rootCertificate, clientKey, clientCertificate);
+}
+function getCredentialsFromEnv(signalIdentifier) {
+    if (getInsecureSettingFromEnv(signalIdentifier)) {
+        return (0, grpc_exporter_transport_1.createInsecureCredentials)();
+    }
+    return getCredentialsFromEnvIgnoreInsecure(signalIdentifier);
+}
+function getOtlpGrpcConfigurationFromEnv(signalIdentifier) {
+    return {
+        ...(0, node_http_1.getSharedConfigurationFromEnvironment)(signalIdentifier),
+        metadata: getMetadataProviderFromEnv(signalIdentifier),
+        url: getUrlFromEnv(signalIdentifier),
+        credentials: (finalResolvedUrl) => {
+            // Always assume insecure on http:// and secure on https://, the protocol always takes precedence over the insecure setting.
+            // note: the spec does not make any exception for
+            // - "localhost:4317". If the protocol is omitted, credentials are required unless insecure is set
+            // - "unix://", as it's neither http:// nor https:// and therefore credentials are required unless insecure is set
+            if (finalResolvedUrl.startsWith('http://')) {
+                return () => {
+                    return (0, grpc_exporter_transport_1.createInsecureCredentials)();
+                };
+            }
+            else if (finalResolvedUrl.startsWith('https://')) {
+                return () => {
+                    return getCredentialsFromEnvIgnoreInsecure(signalIdentifier);
+                };
+            }
+            // defer to env settings in this case
+            return () => {
+                return getCredentialsFromEnv(signalIdentifier);
+            };
+        },
+    };
+}
+exports.getOtlpGrpcConfigurationFromEnv = getOtlpGrpcConfigurationFromEnv;
+//# sourceMappingURL=otlp-grpc-env-configuration.js.map

package/.next/standalone/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/execAsync.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as child_process from 'child_process';
+import * as util from 'util';
+export const execAsync = util.promisify(child_process.exec);
+//# sourceMappingURL=execAsync.js.map

package/.next/standalone/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-bsd.js

@@ -0,0 +1,25 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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

package/.next/standalone/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-darwin.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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

package/.next/standalone/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-linux.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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

package/.next/standalone/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-unsupported.js

@@ -0,0 +1,10 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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

package/.next/standalone/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId-win.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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

package/.next/standalone/node_modules/@opentelemetry/resources/build/esm/detectors/platform/node/machine-id/getMachineId.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as process from 'process';
+let getMachineIdImpl;
+export async function getMachineId() {
+    if (!getMachineIdImpl) {
+        switch (process.platform) {
+            case 'darwin':
+                getMachineIdImpl = (await import('./getMachineId-darwin.js'))
+                    .getMachineId;
+                break;
+            case 'linux':
+                getMachineIdImpl = (await import('./getMachineId-linux.js'))
+                    .getMachineId;
+                break;
+            case 'freebsd':
+                getMachineIdImpl = (await import('./getMachineId-bsd.js')).getMachineId;
+                break;
+            case 'win32':
+                getMachineIdImpl = (await import('./getMachineId-win.js')).getMachineId;
+                break;
+            default:
+                getMachineIdImpl = (await import('./getMachineId-unsupported.js'))
+                    .getMachineId;
+                break;
+        }
+    }
+    return getMachineIdImpl();
+}
+//# sourceMappingURL=getMachineId.js.map