@google/adk 2.3.0 → 2.5.0

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

@@ -0,0 +1,763 @@
+/**
+  * @license
+  * Copyright 2026 Google LLC
+  * SPDX-License-Identifier: Apache-2.0
+  */
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var google_cloud_exports = {};
+__export(google_cloud_exports, {
+  AuthenticatedLogExporter: () => AuthenticatedLogExporter,
+  AuthenticatedMetricExporter: () => AuthenticatedMetricExporter,
+  AuthenticatedTraceExporter: () => AuthenticatedTraceExporter,
+  GCPBatchLogRecordProcessor: () => GCPBatchLogRecordProcessor,
+  agentRuntimeRequestHooks: () => import_agent_runtime.agentRuntimeRequestHooks,
+  clearProjectCache: () => clearProjectCache,
+  fetchProject: () => fetchProject,
+  getAgentEngineUserAgentHeader: () => getAgentEngineUserAgentHeader,
+  getGcpExporters: () => getGcpExporters,
+  getGcpProjectId: () => getGcpProjectId,
+  getGcpResource: () => getGcpResource,
+  getTelemetryEndpoint: () => getTelemetryEndpoint
+});
+module.exports = __toCommonJS(google_cloud_exports);
+var import_api = require("@opentelemetry/api");
+var import_exporter_logs_otlp_http = require("@opentelemetry/exporter-logs-otlp-http");
+var import_exporter_metrics_otlp_http = require("@opentelemetry/exporter-metrics-otlp-http");
+var import_exporter_trace_otlp_http = require("@opentelemetry/exporter-trace-otlp-http");
+var import_resource_detector_gcp = require("@opentelemetry/resource-detector-gcp");
+var import_resources = require("@opentelemetry/resources");
+var import_sdk_logs = require("@opentelemetry/sdk-logs");
+var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_google_auth_library = require("google-auth-library");
+var import_node_crypto = require("node:crypto");
+var fs = __toESM(require("node:fs"), 1);
+var import_logger = require("../../utils/logger.js");
+var import_version = require("../../version.js");
+var import_agent_runtime = require("./agent_runtime.js");
+var import_request_driven_metric_reader = require("./request_driven_metric_reader.js");
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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") {
+    import_logger.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 {
+    import_logger.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/${import_version.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 import_exporter_trace_otlp_http.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;
+        import_logger.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 import_exporter_metrics_otlp_http.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;
+        import_logger.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 import_exporter_logs_otlp_http.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;
+        import_logger.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 (0, import_resources.emptyResource)();
+  }
+  const location = process.env.GOOGLE_CLOUD_AGENT_ENGINE_LOCATION || process.env.GOOGLE_CLOUD_LOCATION || "";
+  return (0, import_resources.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 import_sdk_logs.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 : (0, import_resources.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 import_google_auth_library.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) {
+    import_logger.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 import_google_auth_library.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) {
+    import_logger.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) {
+    import_logger.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) {
+    import_logger.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) {
+    import_logger.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) {
+    import_logger.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 (0, import_resources.emptyResource)();
+  }
+  const workload = urnWorkloadSegment(attributes);
+  if (!workload) {
+    return (0, import_resources.emptyResource)();
+  }
+  const projectId = attributes["cloud.account.id"] || fallbackProjectId;
+  if (!projectId) {
+    import_logger.logger.warn("The project ID is unknown, so no agent URN is set.");
+    return (0, import_resources.emptyResource)();
+  }
+  const projectInfo = await fetchProject(projectId);
+  if (!projectInfo.number) {
+    import_logger.logger.warn(
+      `The number of project '${projectId}' is unknown, so no agent URN is set.`
+    );
+    return (0, import_resources.emptyResource)();
+  }
+  const location = urnLocationSegment(attributes);
+  if (!location) {
+    import_logger.logger.warn(
+      "Neither a zone nor a region could be detected, so no agent URN is set."
+    );
+    return (0, import_resources.emptyResource)();
+  }
+  const urn = [
+    "urn:agent",
+    `projects-${projectInfo.number}`,
+    `projects:${projectInfo.number}`,
+    location,
+    workload
+  ].join(":");
+  return (0, import_resources.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 = `${(0, import_node_crypto.randomUUID)().replace(/-/g, "")}-${process.pid}`;
+  const commonAttributes = {
+    "service.instance.id": instanceId
+  };
+  if (resolvedProjectId) {
+    commonAttributes["gcp.project_id"] = resolvedProjectId;
+    commonAttributes["cloud.account.id"] = resolvedProjectId;
+  } else {
+    import_logger.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 = (0, import_resources.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) {
+      import_logger.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(
+      (0, import_resources.defaultResource)().merge((0, import_resources.resourceFromAttributes)(aeAttributes))
+    );
+  }
+  const otelDetected = (0, import_resources.detectResources)({ detectors: [import_resources.envDetector] });
+  resource = resource.merge(otelDetected);
+  if (!agentEngineId) {
+    try {
+      const gcpDetected = (0, import_resources.detectResources)({ detectors: [import_resource_detector_gcp.gcpDetector] });
+      if (gcpDetected.asyncAttributesPending) {
+        await ((_b = gcpDetected.waitForAsyncAttributes) == null ? void 0 : _b.call(gcpDetected));
+      }
+      resource = resource.merge(gcpDetected);
+    } catch (error) {
+      import_logger.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 (!(import_api.metrics.getMeterProvider() instanceof import_sdk_metrics.MeterProvider)) {
+      return new import_request_driven_metric_reader.RequestDrivenMetricReader({ exporter });
+    }
+    import_logger.logger.warn(
+      "A MeterProvider is already installed; skipping request-driven metric export. On Agent Runtime metrics may be dropped between requests."
+    );
+  }
+  return new import_sdk_metrics.PeriodicExportingMetricReader({
+    exporter,
+    exportIntervalMillis: import_request_driven_metric_reader.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 import_google_auth_library.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) {
+    import_logger.logger.warn(GCP_PROJECT_ERROR_MESSAGE);
+    return {};
+  }
+  const userAgentHeaders = getAgentEngineUserAgentHeader();
+  const spanProcessors = enableTracing ? [
+    new import_sdk_trace_base.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");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticatedLogExporter,
+  AuthenticatedMetricExporter,
+  AuthenticatedTraceExporter,
+  GCPBatchLogRecordProcessor,
+  agentRuntimeRequestHooks,
+  clearProjectCache,
+  fetchProject,
+  getAgentEngineUserAgentHeader,
+  getGcpExporters,
+  getGcpProjectId,
+  getGcpResource,
+  getTelemetryEndpoint
+});