@google/adk 2.4.0 → 2.5.0

package/dist/esm/telemetry/export/google_cloud.js

@@ -0,0 +1,733 @@
+import {createRequire as topLevelCreateRequire} from 'module';
+const require = topLevelCreateRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { metrics } from "@opentelemetry/api";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { gcpDetector } from "@opentelemetry/resource-detector-gcp";
+import {
+  defaultResource,
+  detectResources,
+  emptyResource,
+  envDetector,
+  resourceFromAttributes
+} from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor
+} from "@opentelemetry/sdk-logs";
+import {
+  MeterProvider,
+  PeriodicExportingMetricReader
+} from "@opentelemetry/sdk-metrics";
+import {
+  BatchSpanProcessor
+} from "@opentelemetry/sdk-trace-base";
+import { GoogleAuth } from "google-auth-library";
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import { logger } from "../../utils/logger.js";
+import { version } from "../../version.js";
+import {
+  agentRuntimeRequestHooks
+} from "./agent_runtime.js";
+import {
+  MIN_EXPORT_INTERVAL_MS,
+  RequestDrivenMetricReader
+} from "./request_driven_metric_reader.js";
+const CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
+const DEFAULT_TELEMETRY_TRACES_ENDPOINT = "https://telemetry.googleapis.com/v1/traces";
+const DEFAULT_MTLS_TELEMETRY_TRACES_ENDPOINT = "https://telemetry.mtls.googleapis.com/v1/traces";
+const DEFAULT_TELEMETRY_METRICS_ENDPOINT = "https://telemetry.googleapis.com/v1/metrics";
+const DEFAULT_MTLS_TELEMETRY_METRICS_ENDPOINT = "https://telemetry.mtls.googleapis.com/v1/metrics";
+const DEFAULT_TELEMETRY_LOGS_ENDPOINT = "https://telemetry.googleapis.com/v1/logs";
+const DEFAULT_MTLS_TELEMETRY_LOGS_ENDPOINT = "https://telemetry.mtls.googleapis.com/v1/logs";
+const GCP_PROJECT_ERROR_MESSAGE = "Cannot determine GCP Project. OTel GCP Exporters cannot be set up. Please make sure to log into correct GCP Project.";
+const GCP_DEFAULT_LOG_NAME = "GCP_DEFAULT_LOG_NAME";
+const ADK_OTEL = "adk-otel";
+const DEFAULT_AGENT_ENGINE_LOG_NAME = "aiplatform.googleapis.com/reasoning_engine_stdout";
+const GCP_LOG_NAME = "gcp.log_name";
+const EVENT_NAME = "event.name";
+const GCP_RESOURCE_TYPE = "gcp.resource_type";
+const LOCATION = "location";
+const REASONING_ENGINE_ID = "reasoning_engine_id";
+const RESOURCE_CONTAINER = "resource_container";
+const SERVICE_VERSION = "service.version";
+const POD_NAME_HASHES = /-[a-z0-9]+-[a-z0-9]{5}$/;
+const K8S_NAMESPACE_PATH = "/var/run/secrets/kubernetes.io/serviceaccount/namespace";
+const PROJECT_CACHE_SIZE = 32;
+const projectCache = /* @__PURE__ */ new Map();
+function clearProjectCache() {
+  projectCache.clear();
+}
+__name(clearProjectCache, "clearProjectCache");
+function normalizeHeaders(headers) {
+  if (!headers) {
+    return {};
+  }
+  if (typeof headers.forEach === "function") {
+    const result = {};
+    headers.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  return { ...headers };
+}
+__name(normalizeHeaders, "normalizeHeaders");
+function useClientCertEffective() {
+  var _a;
+  const useClientCertStr = ((_a = process.env.GOOGLE_API_USE_CLIENT_CERTIFICATE) != null ? _a : "false").toLowerCase();
+  if (useClientCertStr !== "true" && useClientCertStr !== "false") {
+    logger.warn(
+      "Environment variable `GOOGLE_API_USE_CLIENT_CERTIFICATE` must be either `true` or `false`"
+    );
+  }
+  return useClientCertStr === "true";
+}
+__name(useClientCertEffective, "useClientCertEffective");
+function getTelemetryEndpoint(defaultEndpoint, mtlsEndpoint) {
+  var _a;
+  const useMtlsEndpointStr = ((_a = process.env.GOOGLE_API_USE_MTLS_ENDPOINT) != null ? _a : "auto").toLowerCase();
+  let useMtlsEndpoint = "auto";
+  if (useMtlsEndpointStr === "auto" || useMtlsEndpointStr === "always" || useMtlsEndpointStr === "never") {
+    useMtlsEndpoint = useMtlsEndpointStr;
+  } else {
+    logger.warn(
+      'Environment variable `GOOGLE_API_USE_MTLS_ENDPOINT` must be one of ["auto", "always", "never"]. Defaulting to auto.'
+    );
+    useMtlsEndpoint = "auto";
+  }
+  if (useMtlsEndpoint === "always") {
+    return mtlsEndpoint;
+  }
+  if (useMtlsEndpoint === "never") {
+    return defaultEndpoint;
+  }
+  if (useClientCertEffective()) {
+    return mtlsEndpoint;
+  }
+  return defaultEndpoint;
+}
+__name(getTelemetryEndpoint, "getTelemetryEndpoint");
+function getAgentEngineUserAgentHeader() {
+  if (!process.env.GOOGLE_CLOUD_AGENT_ENGINE_ENABLE_TELEMETRY) {
+    return {};
+  }
+  return {
+    "User-Agent": `Vertex-Agent-Engine/${version}`
+  };
+}
+__name(getAgentEngineUserAgentHeader, "getAgentEngineUserAgentHeader");
+const _AuthenticatedTraceExporter = class _AuthenticatedTraceExporter {
+  constructor(auth, endpoint, userAgentHeaders = {}) {
+    this.currentHeaders = {};
+    this.warnedAuthFailure = false;
+    this.auth = auth;
+    this.endpoint = endpoint;
+    this.userAgentHeaders = userAgentHeaders;
+    this.delegate = new OTLPTraceExporter({
+      url: endpoint,
+      headers: /* @__PURE__ */ __name(async () => this.currentHeaders, "headers")
+    });
+  }
+  /**
+   * Exports spans to Google Cloud.
+   *
+   * @param spans Spans to export.
+   * @param resultCallback Callback called with the export result.
+   */
+  export(spans, resultCallback) {
+    void this.exportAsync(spans, resultCallback);
+  }
+  async exportAsync(spans, resultCallback) {
+    try {
+      const authHeaders = await this.auth.getRequestHeaders(this.endpoint);
+      this.currentHeaders = {
+        ...normalizeHeaders(authHeaders),
+        ...this.userAgentHeaders
+      };
+    } catch (error) {
+      if (!this.warnedAuthFailure) {
+        this.warnedAuthFailure = true;
+        logger.warn(
+          "Failed to obtain Google Cloud credentials for telemetry export.",
+          { error }
+        );
+      }
+      resultCallback({
+        code: 1,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      return;
+    }
+    this.delegate.export(spans, resultCallback);
+  }
+  /**
+   * Shuts down the trace exporter.
+   */
+  shutdown() {
+    return this.delegate.shutdown();
+  }
+  /**
+   * Flushes pending traces.
+   */
+  forceFlush() {
+    return this.delegate.forceFlush();
+  }
+};
+__name(_AuthenticatedTraceExporter, "AuthenticatedTraceExporter");
+let AuthenticatedTraceExporter = _AuthenticatedTraceExporter;
+const _AuthenticatedMetricExporter = class _AuthenticatedMetricExporter {
+  constructor(auth, endpoint, userAgentHeaders = {}) {
+    this.currentHeaders = {};
+    this.warnedAuthFailure = false;
+    this.auth = auth;
+    this.endpoint = endpoint;
+    this.userAgentHeaders = userAgentHeaders;
+    this.delegate = new OTLPMetricExporter({
+      url: endpoint,
+      headers: /* @__PURE__ */ __name(async () => this.currentHeaders, "headers")
+    });
+  }
+  /**
+   * Exports metrics to Google Cloud.
+   *
+   * @param metrics Metrics to export.
+   * @param resultCallback Callback called with the export result.
+   */
+  export(metrics2, resultCallback) {
+    void this.exportAsync(metrics2, resultCallback);
+  }
+  async exportAsync(metrics2, resultCallback) {
+    try {
+      const authHeaders = await this.auth.getRequestHeaders(this.endpoint);
+      this.currentHeaders = {
+        ...normalizeHeaders(authHeaders),
+        ...this.userAgentHeaders
+      };
+    } catch (error) {
+      if (!this.warnedAuthFailure) {
+        this.warnedAuthFailure = true;
+        logger.warn(
+          "Failed to obtain Google Cloud credentials for telemetry export.",
+          { error }
+        );
+      }
+      resultCallback({
+        code: 1,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      return;
+    }
+    this.delegate.export(metrics2, resultCallback);
+  }
+  /**
+   * Shuts down the metric exporter.
+   */
+  shutdown() {
+    return this.delegate.shutdown();
+  }
+  /**
+   * Flushes pending metrics.
+   */
+  forceFlush() {
+    return this.delegate.forceFlush();
+  }
+  /**
+   * Selects aggregation temporality for instrument type.
+   *
+   * @param instrumentType Instrument type.
+   */
+  selectAggregationTemporality(instrumentType) {
+    return this.delegate.selectAggregationTemporality(instrumentType);
+  }
+};
+__name(_AuthenticatedMetricExporter, "AuthenticatedMetricExporter");
+let AuthenticatedMetricExporter = _AuthenticatedMetricExporter;
+const _AuthenticatedLogExporter = class _AuthenticatedLogExporter {
+  constructor(auth, endpoint, userAgentHeaders = {}) {
+    this.currentHeaders = {};
+    this.warnedAuthFailure = false;
+    this.auth = auth;
+    this.endpoint = endpoint;
+    this.userAgentHeaders = userAgentHeaders;
+    this.delegate = new OTLPLogExporter({
+      url: endpoint,
+      headers: /* @__PURE__ */ __name(async () => this.currentHeaders, "headers")
+    });
+  }
+  /**
+   * Exports log records to Google Cloud.
+   *
+   * @param logs Log records to export.
+   * @param resultCallback Callback called with the export result.
+   */
+  export(logs, resultCallback) {
+    void this.exportAsync(logs, resultCallback);
+  }
+  async exportAsync(logs, resultCallback) {
+    try {
+      const authHeaders = await this.auth.getRequestHeaders(this.endpoint);
+      this.currentHeaders = {
+        ...normalizeHeaders(authHeaders),
+        ...this.userAgentHeaders
+      };
+    } catch (error) {
+      if (!this.warnedAuthFailure) {
+        this.warnedAuthFailure = true;
+        logger.warn(
+          "Failed to obtain Google Cloud credentials for telemetry export.",
+          { error }
+        );
+      }
+      resultCallback({
+        code: 1,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      return;
+    }
+    this.delegate.export(logs, resultCallback);
+  }
+  /**
+   * Shuts down the log exporter.
+   */
+  shutdown() {
+    return this.delegate.shutdown();
+  }
+  /**
+   * Flushes pending log records.
+   */
+  forceFlush() {
+    return this.delegate.forceFlush();
+  }
+};
+__name(_AuthenticatedLogExporter, "AuthenticatedLogExporter");
+let AuthenticatedLogExporter = _AuthenticatedLogExporter;
+function agentEngineLogResource(projectId) {
+  const agentEngineId = process.env.GOOGLE_CLOUD_AGENT_ENGINE_ID;
+  if (!agentEngineId) {
+    return emptyResource();
+  }
+  const location = process.env.GOOGLE_CLOUD_AGENT_ENGINE_LOCATION || process.env.GOOGLE_CLOUD_LOCATION || "";
+  return resourceFromAttributes({
+    [GCP_RESOURCE_TYPE]: "aiplatform.googleapis.com/ReasoningEngine",
+    [LOCATION]: location,
+    [REASONING_ENGINE_ID]: agentEngineId,
+    [RESOURCE_CONTAINER]: `projects/${projectId}`
+  });
+}
+__name(agentEngineLogResource, "agentEngineLogResource");
+const _GCPBatchLogRecordProcessor = class _GCPBatchLogRecordProcessor extends BatchLogRecordProcessor {
+  constructor(exporterOrOptions, projectId) {
+    var _a, _b;
+    const options = "export" in exporterOrOptions ? { exporter: exporterOrOptions } : exporterOrOptions;
+    super(options);
+    const effectiveProjectId = (_a = projectId != null ? projectId : "projectId" in exporterOrOptions ? exporterOrOptions.projectId : void 0) != null ? _a : "";
+    this.logResource = agentEngineLogResource(effectiveProjectId);
+    const defaultLogNameEnv = (_b = process.env[GCP_DEFAULT_LOG_NAME]) == null ? void 0 : _b.trim();
+    this.defaultLogName = defaultLogNameEnv && defaultLogNameEnv.length > 0 ? defaultLogNameEnv : process.env.GOOGLE_CLOUD_AGENT_ENGINE_ID ? DEFAULT_AGENT_ENGINE_LOG_NAME : ADK_OTEL;
+  }
+  onEmit(logRecord) {
+    var _a, _b, _c, _d;
+    const attributes = { ...logRecord.attributes };
+    if (logRecord.eventName) {
+      attributes[EVENT_NAME] = (_a = attributes[EVENT_NAME]) != null ? _a : logRecord.eventName;
+    }
+    attributes[GCP_LOG_NAME] = (_b = attributes[GCP_LOG_NAME]) != null ? _b : this.defaultLogName;
+    const baseResource = (_c = logRecord.resource) != null ? _c : emptyResource();
+    const mergedResource = baseResource.merge(this.logResource);
+    const serviceVersion = mergedResource.attributes[SERVICE_VERSION];
+    if (serviceVersion !== void 0) {
+      attributes[SERVICE_VERSION] = (_d = attributes[SERVICE_VERSION]) != null ? _d : serviceVersion;
+    }
+    const emitted = Object.create(
+      Object.getPrototypeOf(logRecord),
+      {
+        ...Object.getOwnPropertyDescriptors(logRecord),
+        resource: {
+          value: mergedResource,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        },
+        attributes: {
+          value: attributes,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        },
+        ...process.env.GOOGLE_CLOUD_AGENT_ENGINE_ID && logRecord.eventName ? {
+          eventName: {
+            value: void 0,
+            writable: true,
+            enumerable: true,
+            configurable: true
+          },
+          _eventName: {
+            value: void 0,
+            writable: true,
+            enumerable: false,
+            configurable: true
+          }
+        } : {}
+      }
+    );
+    super.onEmit(emitted);
+  }
+};
+__name(_GCPBatchLogRecordProcessor, "GCPBatchLogRecordProcessor");
+let GCPBatchLogRecordProcessor = _GCPBatchLogRecordProcessor;
+async function fetchProject(project, auth) {
+  var _a;
+  if (!project) {
+    return { id: "", number: "" };
+  }
+  const cached = projectCache.get(project);
+  if (cached) {
+    return cached;
+  }
+  const isDigits = /^\d+$/.test(project);
+  const known = {
+    id: isDigits ? "" : project,
+    number: ""
+  };
+  try {
+    const authClient = auth != null ? auth : new GoogleAuth({
+      scopes: [CLOUD_PLATFORM_SCOPE]
+    });
+    const url = `https://cloudresourcemanager.googleapis.com/v3/projects/${encodeURIComponent(project)}`;
+    const response = await authClient.request({
+      url
+    });
+    const data = response.data;
+    const projectNumber = (data == null ? void 0 : data.name) ? data.name.replace(/^projects\//, "") : "";
+    const projectId = (_a = data == null ? void 0 : data.projectId) != null ? _a : isDigits ? "" : project;
+    const resolved = {
+      id: projectId,
+      number: projectNumber
+    };
+    if (projectCache.size >= PROJECT_CACHE_SIZE) {
+      const firstKey = projectCache.keys().next().value;
+      if (firstKey !== void 0) {
+        projectCache.delete(firstKey);
+      }
+    }
+    projectCache.set(project, resolved);
+    return resolved;
+  } catch (error) {
+    logger.warn(
+      "Failed to look up the project's other identifier. Your traces and logs may not be associated, and the agent URN may be incomplete. To fix this, ensure the Cloud Resource Manager API is enabled with the 'resourcemanager.projects.get' permission.",
+      { error }
+    );
+    return known;
+  }
+}
+__name(fetchProject, "fetchProject");
+async function getGcpProjectId(auth) {
+  if (process.env.GOOGLE_CLOUD_PROJECT) {
+    return process.env.GOOGLE_CLOUD_PROJECT;
+  }
+  try {
+    const authClient = auth != null ? auth : new GoogleAuth({
+      scopes: [CLOUD_PLATFORM_SCOPE]
+    });
+    const projectId = await authClient.getProjectId();
+    return projectId || void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(getGcpProjectId, "getGcpProjectId");
+function k8sNamespace() {
+  try {
+    return fs.readFileSync(K8S_NAMESPACE_PATH, "utf8").trim();
+  } catch {
+    return "";
+  }
+}
+__name(k8sNamespace, "k8sNamespace");
+function k8sDeployment() {
+  var _a;
+  const hostname = (_a = process.env.HOSTNAME) != null ? _a : "";
+  if (POD_NAME_HASHES.test(hostname)) {
+    return hostname.replace(POD_NAME_HASHES, "");
+  }
+  return "";
+}
+__name(k8sDeployment, "k8sDeployment");
+function urnAgentRuntimeSegment() {
+  const agentEngineId = process.env.GOOGLE_CLOUD_AGENT_ENGINE_ID;
+  if (!agentEngineId) {
+    logger.warn(
+      "The Agent Runtime instance ID is unknown, so no agent URN is set."
+    );
+    return "";
+  }
+  return `aiplatform:reasoningEngines:${agentEngineId}`;
+}
+__name(urnAgentRuntimeSegment, "urnAgentRuntimeSegment");
+function urnGkeSegment(attributes) {
+  const cluster = attributes["k8s.cluster.name"] || "";
+  const namespace = attributes["k8s.namespace.name"] || k8sNamespace();
+  const deployment = attributes["k8s.deployment.name"] || k8sDeployment();
+  if (!cluster) {
+    logger.warn(
+      "The GKE cluster is unknown, so no agent URN is set. Set k8s.cluster.name in OTEL_RESOURCE_ATTRIBUTES to state it."
+    );
+  }
+  if (!namespace) {
+    logger.warn(
+      "The GKE namespace is unknown, so no agent URN is set. Set k8s.namespace.name in OTEL_RESOURCE_ATTRIBUTES to state it."
+    );
+  }
+  if (!deployment) {
+    logger.warn(
+      "The GKE Deployment is unknown, so no agent URN is set. Set k8s.deployment.name in OTEL_RESOURCE_ATTRIBUTES to state it."
+    );
+  }
+  if (!cluster || !namespace || !deployment) {
+    return "";
+  }
+  return `container:clusters:${cluster}:k8s:namespaces:${namespace}:apps:deployments:${deployment}`;
+}
+__name(urnGkeSegment, "urnGkeSegment");
+function urnCloudRunSegment(attributes) {
+  const service = attributes["faas.name"] || "";
+  if (!service) {
+    logger.warn(
+      "The Cloud Run service name is unknown, so no agent URN is set."
+    );
+    return "";
+  }
+  return `run:services:${service}`;
+}
+__name(urnCloudRunSegment, "urnCloudRunSegment");
+function urnWorkloadSegment(attributes) {
+  const platform = attributes["cloud.platform"];
+  if (platform === "gcp.agent_engine") {
+    return urnAgentRuntimeSegment();
+  }
+  if (platform === "gcp_kubernetes_engine") {
+    return urnGkeSegment(attributes);
+  }
+  if (platform === "gcp_cloud_run") {
+    return urnCloudRunSegment(attributes);
+  }
+  return null;
+}
+__name(urnWorkloadSegment, "urnWorkloadSegment");
+function urnLocationSegment(attributes) {
+  const zone = attributes["cloud.availability_zone"];
+  if (zone) {
+    return `zones:${zone}`;
+  }
+  const region = attributes["cloud.region"];
+  if (region) {
+    return `locations:${region}`;
+  }
+  return "";
+}
+__name(urnLocationSegment, "urnLocationSegment");
+async function getUrnEnrichedResource(resource, fallbackProjectId) {
+  const attributes = resource.attributes;
+  if (attributes["gen_ai.main_agent.id"]) {
+    return emptyResource();
+  }
+  const workload = urnWorkloadSegment(attributes);
+  if (!workload) {
+    return emptyResource();
+  }
+  const projectId = attributes["cloud.account.id"] || fallbackProjectId;
+  if (!projectId) {
+    logger.warn("The project ID is unknown, so no agent URN is set.");
+    return emptyResource();
+  }
+  const projectInfo = await fetchProject(projectId);
+  if (!projectInfo.number) {
+    logger.warn(
+      `The number of project '${projectId}' is unknown, so no agent URN is set.`
+    );
+    return emptyResource();
+  }
+  const location = urnLocationSegment(attributes);
+  if (!location) {
+    logger.warn(
+      "Neither a zone nor a region could be detected, so no agent URN is set."
+    );
+    return emptyResource();
+  }
+  const urn = [
+    "urn:agent",
+    `projects-${projectInfo.number}`,
+    `projects:${projectInfo.number}`,
+    location,
+    workload
+  ].join(":");
+  return resourceFromAttributes({ "gen_ai.main_agent.id": urn });
+}
+__name(getUrnEnrichedResource, "getUrnEnrichedResource");
+async function getGcpResource(projectId) {
+  var _a, _b;
+  let resolvedProjectId = projectId;
+  if (!resolvedProjectId) {
+    resolvedProjectId = await getGcpProjectId();
+  }
+  const instanceId = `${randomUUID().replace(/-/g, "")}-${process.pid}`;
+  const commonAttributes = {
+    "service.instance.id": instanceId
+  };
+  if (resolvedProjectId) {
+    commonAttributes["gcp.project_id"] = resolvedProjectId;
+    commonAttributes["cloud.account.id"] = resolvedProjectId;
+  } else {
+    logger.warn(
+      "No project could be determined, so telemetry will not name one. Set GOOGLE_CLOUD_PROJECT, or pass a project explicitly, if it should."
+    );
+  }
+  let resource = resourceFromAttributes(commonAttributes);
+  const agentEngineId = process.env.GOOGLE_CLOUD_AGENT_ENGINE_ID;
+  if (agentEngineId) {
+    const location = process.env.GOOGLE_CLOUD_AGENT_ENGINE_LOCATION || process.env.GOOGLE_CLOUD_LOCATION || "";
+    if (!location) {
+      logger.warn(
+        "On Agent Runtime with no location set, so this deployment cannot be named. Set GOOGLE_CLOUD_AGENT_ENGINE_LOCATION or GOOGLE_CLOUD_LOCATION."
+      );
+    }
+    const aeAttributes = {
+      "cloud.provider": "gcp",
+      "cloud.platform": "gcp.agent_engine",
+      "service.name": agentEngineId,
+      "service.version": (_a = process.env.GOOGLE_CLOUD_AGENT_ENGINE_RUNTIME_REVISION_ID) != null ? _a : "",
+      "cloud.region": location
+    };
+    if (resolvedProjectId && location) {
+      aeAttributes["cloud.resource_id"] = `//aiplatform.googleapis.com/projects/${resolvedProjectId}/locations/${location}/reasoningEngines/${agentEngineId}`;
+    }
+    resource = resource.merge(
+      defaultResource().merge(resourceFromAttributes(aeAttributes))
+    );
+  }
+  const otelDetected = detectResources({ detectors: [envDetector] });
+  resource = resource.merge(otelDetected);
+  if (!agentEngineId) {
+    try {
+      const gcpDetected = detectResources({ detectors: [gcpDetector] });
+      if (gcpDetected.asyncAttributesPending) {
+        await ((_b = gcpDetected.waitForAsyncAttributes) == null ? void 0 : _b.call(gcpDetected));
+      }
+      resource = resource.merge(gcpDetected);
+    } catch (error) {
+      logger.warn(
+        "Could not detect GCP resource attributes. GCE, GKE or CloudRun related resource attributes may be missing.",
+        { error }
+      );
+    }
+  }
+  const urnResource = await getUrnEnrichedResource(resource, resolvedProjectId);
+  resource = resource.merge(urnResource);
+  return resource;
+}
+__name(getGcpResource, "getGcpResource");
+function createMetricReader(exporter) {
+  if (process.env.GOOGLE_CLOUD_AGENT_ENGINE_ID) {
+    if (!(metrics.getMeterProvider() instanceof MeterProvider)) {
+      return new RequestDrivenMetricReader({ exporter });
+    }
+    logger.warn(
+      "A MeterProvider is already installed; skipping request-driven metric export. On Agent Runtime metrics may be dropped between requests."
+    );
+  }
+  return new PeriodicExportingMetricReader({
+    exporter,
+    exportIntervalMillis: MIN_EXPORT_INTERVAL_MS
+  });
+}
+__name(createMetricReader, "createMetricReader");
+async function getGcpExporters(config = {}) {
+  const {
+    enableTracing = false,
+    enableMetrics = false,
+    enableLogging = false,
+    auth: providedAuth
+  } = config;
+  const auth = providedAuth != null ? providedAuth : new GoogleAuth({
+    scopes: [CLOUD_PLATFORM_SCOPE]
+  });
+  let projectId = config.projectId;
+  if (!projectId) {
+    projectId = await getGcpProjectId(auth);
+  }
+  if (process.env.GOOGLE_CLOUD_AGENT_ENGINE_ID && projectId) {
+    const projectInfo = await fetchProject(projectId, auth);
+    projectId = projectInfo.id || projectId;
+  }
+  if (!projectId) {
+    logger.warn(GCP_PROJECT_ERROR_MESSAGE);
+    return {};
+  }
+  const userAgentHeaders = getAgentEngineUserAgentHeader();
+  const spanProcessors = enableTracing ? [
+    new BatchSpanProcessor(
+      new AuthenticatedTraceExporter(
+        auth,
+        getTelemetryEndpoint(
+          DEFAULT_TELEMETRY_TRACES_ENDPOINT,
+          DEFAULT_MTLS_TELEMETRY_TRACES_ENDPOINT
+        ),
+        userAgentHeaders
+      )
+    )
+  ] : [];
+  const metricReaders = enableMetrics ? [
+    createMetricReader(
+      new AuthenticatedMetricExporter(
+        auth,
+        getTelemetryEndpoint(
+          DEFAULT_TELEMETRY_METRICS_ENDPOINT,
+          DEFAULT_MTLS_TELEMETRY_METRICS_ENDPOINT
+        ),
+        userAgentHeaders
+      )
+    )
+  ] : [];
+  const logRecordProcessors = enableLogging ? [
+    new GCPBatchLogRecordProcessor(
+      new AuthenticatedLogExporter(
+        auth,
+        getTelemetryEndpoint(
+          DEFAULT_TELEMETRY_LOGS_ENDPOINT,
+          DEFAULT_MTLS_TELEMETRY_LOGS_ENDPOINT
+        ),
+        userAgentHeaders
+      ),
+      projectId
+    )
+  ] : [];
+  return {
+    spanProcessors,
+    metricReaders,
+    logRecordProcessors
+  };
+}
+__name(getGcpExporters, "getGcpExporters");
+export {
+  AuthenticatedLogExporter,
+  AuthenticatedMetricExporter,
+  AuthenticatedTraceExporter,
+  GCPBatchLogRecordProcessor,
+  agentRuntimeRequestHooks,
+  clearProjectCache,
+  fetchProject,
+  getAgentEngineUserAgentHeader,
+  getGcpExporters,
+  getGcpProjectId,
+  getGcpResource,
+  getTelemetryEndpoint
+};