@frengki0707/google-cloud-clone 1.33.0

package/lib/gcpLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/gcpLogger.ts"],"sourcesContent":["/**\n * Copyright 2024 Google LLC\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 *     http://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 { LoggingWinston } from '@google-cloud/logging-winston';\nimport { getCurrentEnv } from 'genkit';\nimport { logger } from 'genkit/logging';\nimport type { Writable } from 'stream';\nimport type { GcpTelemetryConfig } from './types.js';\nimport { loggingDenied, loggingDeniedHelpText } from './utils.js';\n\n/**\n * Additional streams for writing log data to. Useful for unit testing.\n */\nlet additionalStream: Writable;\nlet useJsonFormatOverride = false;\n\n/**\n * Provides a logger for exporting Genkit debug logs to GCP Cloud\n * logs.\n */\nexport class GcpLogger {\n  constructor(private readonly config: GcpTelemetryConfig) {}\n\n  async getLogger(env: string) {\n    // Dynamically importing winston here more strictly controls\n    // the import order relative to registering instrumentation\n    // with OpenTelemetry. Incorrect import order will trigger\n    // an internal OT warning and will result in logs not being\n    // associated with correct spans/traces.\n    const winston = await import('winston');\n\n    const format =\n      useJsonFormatOverride || this.shouldExport(env)\n        ? { format: winston.format.json() }\n        : {\n            format: winston.format.printf((info): string => {\n              return `[${info.level}] ${info.message}`;\n            }),\n          };\n\n    const transports: any[] = [];\n    transports.push(\n      this.shouldExport(env)\n        ? new LoggingWinston({\n            labels: { module: 'genkit' },\n            prefix: 'genkit',\n            logName: 'genkit_log',\n            projectId: this.config.projectId,\n            credentials: this.config.credentials,\n            autoRetry: true,\n            defaultCallback: await this.getErrorHandler(),\n          })\n        : new winston.transports.Console()\n    );\n    if (additionalStream) {\n      transports.push(\n        new winston.transports.Stream({ stream: additionalStream })\n      );\n    }\n    return winston.createLogger({\n      transports: transports,\n      ...format,\n      exceptionHandlers: [new winston.transports.Console()],\n    });\n  }\n\n  private async getErrorHandler(): Promise<(err: Error | null) => void> {\n    // only log the first time\n    let instructionsLogged = false;\n    const helpInstructions = await loggingDeniedHelpText();\n\n    return async (err: Error | null) => {\n      // Use the defaultLogger so that logs don't get swallowed by\n      // the open telemetry exporter\n      const defaultLogger = logger.defaultLogger;\n      if (err && loggingDenied(err)) {\n        if (!instructionsLogged) {\n          instructionsLogged = true;\n          defaultLogger.error(\n            `Unable to send logs to Google Cloud: ${err.message}\\n\\n${helpInstructions}\\n`\n          );\n        }\n      } else if (err) {\n        defaultLogger.error(`Unable to send logs to Google Cloud: ${err}`);\n      }\n\n      if (err) {\n        // Assume the logger is compromised, and we need a new one\n        // Reinitialize the genkit logger with a new instance with the same config\n        logger.init(\n          await new GcpLogger(this.config).getLogger(getCurrentEnv())\n        );\n        defaultLogger.info('Initialized a new GcpLogger.');\n      }\n    };\n  }\n\n  private shouldExport(env?: string) {\n    return this.config.export;\n  }\n}\n\n/** @hidden */\nexport function __addTransportStreamForTesting(stream: Writable) {\n  additionalStream = stream;\n}\n\n/** @hidden */\nexport function __useJsonFormatForTesting() {\n  useJsonFormatOverride = true;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,6BAA+B;AAC/B,oBAA8B;AAC9B,qBAAuB;AAGvB,mBAAqD;AAKrD,IAAI;AACJ,IAAI,wBAAwB;AAMrB,MAAM,UAAU;AAAA,EACrB,YAA6B,QAA4B;AAA5B;AAAA,EAA6B;AAAA,EAE1D,MAAM,UAAU,KAAa;AAM3B,UAAM,UAAU,MAAM,OAAO,SAAS;AAEtC,UAAM,SACJ,yBAAyB,KAAK,aAAa,GAAG,IAC1C,EAAE,QAAQ,QAAQ,OAAO,KAAK,EAAE,IAChC;AAAA,MACE,QAAQ,QAAQ,OAAO,OAAO,CAAC,SAAiB;AAC9C,eAAO,IAAI,KAAK,KAAK,KAAK,KAAK,OAAO;AAAA,MACxC,CAAC;AAAA,IACH;AAEN,UAAM,aAAoB,CAAC;AAC3B,eAAW;AAAA,MACT,KAAK,aAAa,GAAG,IACjB,IAAI,sCAAe;AAAA,QACjB,QAAQ,EAAE,QAAQ,SAAS;AAAA,QAC3B,QAAQ;AAAA,QACR,SAAS;AAAA,QACT,WAAW,KAAK,OAAO;AAAA,QACvB,aAAa,KAAK,OAAO;AAAA,QACzB,WAAW;AAAA,QACX,iBAAiB,MAAM,KAAK,gBAAgB;AAAA,MAC9C,CAAC,IACD,IAAI,QAAQ,WAAW,QAAQ;AAAA,IACrC;AACA,QAAI,kBAAkB;AACpB,iBAAW;AAAA,QACT,IAAI,QAAQ,WAAW,OAAO,EAAE,QAAQ,iBAAiB,CAAC;AAAA,MAC5D;AAAA,IACF;AACA,WAAO,QAAQ,aAAa;AAAA,MAC1B;AAAA,MACA,GAAG;AAAA,MACH,mBAAmB,CAAC,IAAI,QAAQ,WAAW,QAAQ,CAAC;AAAA,IACtD,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,kBAAwD;AAEpE,QAAI,qBAAqB;AACzB,UAAM,mBAAmB,UAAM,oCAAsB;AAErD,WAAO,OAAO,QAAsB;AAGlC,YAAM,gBAAgB,sBAAO;AAC7B,UAAI,WAAO,4BAAc,GAAG,GAAG;AAC7B,YAAI,CAAC,oBAAoB;AACvB,+BAAqB;AACrB,wBAAc;AAAA,YACZ,wCAAwC,IAAI,OAAO;AAAA;AAAA,EAAO,gBAAgB;AAAA;AAAA,UAC5E;AAAA,QACF;AAAA,MACF,WAAW,KAAK;AACd,sBAAc,MAAM,wCAAwC,GAAG,EAAE;AAAA,MACnE;AAEA,UAAI,KAAK;AAGP,8BAAO;AAAA,UACL,MAAM,IAAI,UAAU,KAAK,MAAM,EAAE,cAAU,6BAAc,CAAC;AAAA,QAC5D;AACA,sBAAc,KAAK,8BAA8B;AAAA,MACnD;AAAA,IACF;AAAA,EACF;AAAA,EAEQ,aAAa,KAAc;AACjC,WAAO,KAAK,OAAO;AAAA,EACrB;AACF;AAGO,SAAS,+BAA+B,QAAkB;AAC/D,qBAAmB;AACrB;AAGO,SAAS,4BAA4B;AAC1C,0BAAwB;AAC1B;","names":[]}

package/lib/gcpLogger.mjs

@@ -0,0 +1,82 @@
+import { LoggingWinston } from "@google-cloud/logging-winston";
+import { getCurrentEnv } from "genkit";
+import { logger } from "genkit/logging";
+import { loggingDenied, loggingDeniedHelpText } from "./utils.js";
+let additionalStream;
+let useJsonFormatOverride = false;
+class GcpLogger {
+  constructor(config) {
+    this.config = config;
+  }
+  async getLogger(env) {
+    const winston = await import("winston");
+    const format = useJsonFormatOverride || this.shouldExport(env) ? { format: winston.format.json() } : {
+      format: winston.format.printf((info) => {
+        return `[${info.level}] ${info.message}`;
+      })
+    };
+    const transports = [];
+    transports.push(
+      this.shouldExport(env) ? new LoggingWinston({
+        labels: { module: "genkit" },
+        prefix: "genkit",
+        logName: "genkit_log",
+        projectId: this.config.projectId,
+        credentials: this.config.credentials,
+        autoRetry: true,
+        defaultCallback: await this.getErrorHandler()
+      }) : new winston.transports.Console()
+    );
+    if (additionalStream) {
+      transports.push(
+        new winston.transports.Stream({ stream: additionalStream })
+      );
+    }
+    return winston.createLogger({
+      transports,
+      ...format,
+      exceptionHandlers: [new winston.transports.Console()]
+    });
+  }
+  async getErrorHandler() {
+    let instructionsLogged = false;
+    const helpInstructions = await loggingDeniedHelpText();
+    return async (err) => {
+      const defaultLogger = logger.defaultLogger;
+      if (err && loggingDenied(err)) {
+        if (!instructionsLogged) {
+          instructionsLogged = true;
+          defaultLogger.error(
+            `Unable to send logs to Google Cloud: ${err.message}
+
+${helpInstructions}
+`
+          );
+        }
+      } else if (err) {
+        defaultLogger.error(`Unable to send logs to Google Cloud: ${err}`);
+      }
+      if (err) {
+        logger.init(
+          await new GcpLogger(this.config).getLogger(getCurrentEnv())
+        );
+        defaultLogger.info("Initialized a new GcpLogger.");
+      }
+    };
+  }
+  shouldExport(env) {
+    return this.config.export;
+  }
+}
+function __addTransportStreamForTesting(stream) {
+  additionalStream = stream;
+}
+function __useJsonFormatForTesting() {
+  useJsonFormatOverride = true;
+}
+export {
+  GcpLogger,
+  __addTransportStreamForTesting,
+  __useJsonFormatForTesting
+};
+//# sourceMappingURL=gcpLogger.mjs.map

package/lib/gcpLogger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/gcpLogger.ts"],"sourcesContent":["/**\n * Copyright 2024 Google LLC\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 *     http://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 { LoggingWinston } from '@google-cloud/logging-winston';\nimport { getCurrentEnv } from 'genkit';\nimport { logger } from 'genkit/logging';\nimport type { Writable } from 'stream';\nimport type { GcpTelemetryConfig } from './types.js';\nimport { loggingDenied, loggingDeniedHelpText } from './utils.js';\n\n/**\n * Additional streams for writing log data to. Useful for unit testing.\n */\nlet additionalStream: Writable;\nlet useJsonFormatOverride = false;\n\n/**\n * Provides a logger for exporting Genkit debug logs to GCP Cloud\n * logs.\n */\nexport class GcpLogger {\n  constructor(private readonly config: GcpTelemetryConfig) {}\n\n  async getLogger(env: string) {\n    // Dynamically importing winston here more strictly controls\n    // the import order relative to registering instrumentation\n    // with OpenTelemetry. Incorrect import order will trigger\n    // an internal OT warning and will result in logs not being\n    // associated with correct spans/traces.\n    const winston = await import('winston');\n\n    const format =\n      useJsonFormatOverride || this.shouldExport(env)\n        ? { format: winston.format.json() }\n        : {\n            format: winston.format.printf((info): string => {\n              return `[${info.level}] ${info.message}`;\n            }),\n          };\n\n    const transports: any[] = [];\n    transports.push(\n      this.shouldExport(env)\n        ? new LoggingWinston({\n            labels: { module: 'genkit' },\n            prefix: 'genkit',\n            logName: 'genkit_log',\n            projectId: this.config.projectId,\n            credentials: this.config.credentials,\n            autoRetry: true,\n            defaultCallback: await this.getErrorHandler(),\n          })\n        : new winston.transports.Console()\n    );\n    if (additionalStream) {\n      transports.push(\n        new winston.transports.Stream({ stream: additionalStream })\n      );\n    }\n    return winston.createLogger({\n      transports: transports,\n      ...format,\n      exceptionHandlers: [new winston.transports.Console()],\n    });\n  }\n\n  private async getErrorHandler(): Promise<(err: Error | null) => void> {\n    // only log the first time\n    let instructionsLogged = false;\n    const helpInstructions = await loggingDeniedHelpText();\n\n    return async (err: Error | null) => {\n      // Use the defaultLogger so that logs don't get swallowed by\n      // the open telemetry exporter\n      const defaultLogger = logger.defaultLogger;\n      if (err && loggingDenied(err)) {\n        if (!instructionsLogged) {\n          instructionsLogged = true;\n          defaultLogger.error(\n            `Unable to send logs to Google Cloud: ${err.message}\\n\\n${helpInstructions}\\n`\n          );\n        }\n      } else if (err) {\n        defaultLogger.error(`Unable to send logs to Google Cloud: ${err}`);\n      }\n\n      if (err) {\n        // Assume the logger is compromised, and we need a new one\n        // Reinitialize the genkit logger with a new instance with the same config\n        logger.init(\n          await new GcpLogger(this.config).getLogger(getCurrentEnv())\n        );\n        defaultLogger.info('Initialized a new GcpLogger.');\n      }\n    };\n  }\n\n  private shouldExport(env?: string) {\n    return this.config.export;\n  }\n}\n\n/** @hidden */\nexport function __addTransportStreamForTesting(stream: Writable) {\n  additionalStream = stream;\n}\n\n/** @hidden */\nexport function __useJsonFormatForTesting() {\n  useJsonFormatOverride = true;\n}\n"],"mappings":"AAgBA,SAAS,sBAAsB;AAC/B,SAAS,qBAAqB;AAC9B,SAAS,cAAc;AAGvB,SAAS,eAAe,6BAA6B;AAKrD,IAAI;AACJ,IAAI,wBAAwB;AAMrB,MAAM,UAAU;AAAA,EACrB,YAA6B,QAA4B;AAA5B;AAAA,EAA6B;AAAA,EAE1D,MAAM,UAAU,KAAa;AAM3B,UAAM,UAAU,MAAM,OAAO,SAAS;AAEtC,UAAM,SACJ,yBAAyB,KAAK,aAAa,GAAG,IAC1C,EAAE,QAAQ,QAAQ,OAAO,KAAK,EAAE,IAChC;AAAA,MACE,QAAQ,QAAQ,OAAO,OAAO,CAAC,SAAiB;AAC9C,eAAO,IAAI,KAAK,KAAK,KAAK,KAAK,OAAO;AAAA,MACxC,CAAC;AAAA,IACH;AAEN,UAAM,aAAoB,CAAC;AAC3B,eAAW;AAAA,MACT,KAAK,aAAa,GAAG,IACjB,IAAI,eAAe;AAAA,QACjB,QAAQ,EAAE,QAAQ,SAAS;AAAA,QAC3B,QAAQ;AAAA,QACR,SAAS;AAAA,QACT,WAAW,KAAK,OAAO;AAAA,QACvB,aAAa,KAAK,OAAO;AAAA,QACzB,WAAW;AAAA,QACX,iBAAiB,MAAM,KAAK,gBAAgB;AAAA,MAC9C,CAAC,IACD,IAAI,QAAQ,WAAW,QAAQ;AAAA,IACrC;AACA,QAAI,kBAAkB;AACpB,iBAAW;AAAA,QACT,IAAI,QAAQ,WAAW,OAAO,EAAE,QAAQ,iBAAiB,CAAC;AAAA,MAC5D;AAAA,IACF;AACA,WAAO,QAAQ,aAAa;AAAA,MAC1B;AAAA,MACA,GAAG;AAAA,MACH,mBAAmB,CAAC,IAAI,QAAQ,WAAW,QAAQ,CAAC;AAAA,IACtD,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,kBAAwD;AAEpE,QAAI,qBAAqB;AACzB,UAAM,mBAAmB,MAAM,sBAAsB;AAErD,WAAO,OAAO,QAAsB;AAGlC,YAAM,gBAAgB,OAAO;AAC7B,UAAI,OAAO,cAAc,GAAG,GAAG;AAC7B,YAAI,CAAC,oBAAoB;AACvB,+BAAqB;AACrB,wBAAc;AAAA,YACZ,wCAAwC,IAAI,OAAO;AAAA;AAAA,EAAO,gBAAgB;AAAA;AAAA,UAC5E;AAAA,QACF;AAAA,MACF,WAAW,KAAK;AACd,sBAAc,MAAM,wCAAwC,GAAG,EAAE;AAAA,MACnE;AAEA,UAAI,KAAK;AAGP,eAAO;AAAA,UACL,MAAM,IAAI,UAAU,KAAK,MAAM,EAAE,UAAU,cAAc,CAAC;AAAA,QAC5D;AACA,sBAAc,KAAK,8BAA8B;AAAA,MACnD;AAAA,IACF;AAAA,EACF;AAAA,EAEQ,aAAa,KAAc;AACjC,WAAO,KAAK,OAAO;AAAA,EACrB;AACF;AAGO,SAAS,+BAA+B,QAAkB;AAC/D,qBAAmB;AACrB;AAGO,SAAS,4BAA4B;AAC1C,0BAAwB;AAC1B;","names":[]}

package/lib/gcpOpenTelemetry.d.mts

@@ -0,0 +1,59 @@
+import { InMemoryMetricExporter } from '@opentelemetry/sdk-metrics';
+import { NodeSDKConfiguration } from '@opentelemetry/sdk-node';
+import { InMemorySpanExporter } from '@opentelemetry/sdk-trace-base';
+import { GcpTelemetryConfig } from './types.mjs';
+import '@opentelemetry/auto-instrumentations-node';
+import '@opentelemetry/instrumentation';
+import 'google-auth-library';
+
+/**
+ * Copyright 2024 Google LLC
+ *
+ * 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.
+ */
+
+/**
+ * Provides a {TelemetryConfig} for exporting OpenTelemetry data (Traces,
+ * Metrics, and Logs) to the Google Cloud Operations Suite.
+ */
+declare class GcpOpenTelemetry {
+    private readonly config;
+    private readonly resource;
+    constructor(config: GcpTelemetryConfig);
+    /**
+     * Log hook for writing trace and span metadata to log messages in the format
+     * required by GCP.
+     */
+    private gcpTraceLogHook;
+    getConfig(): Promise<Partial<NodeSDKConfiguration>>;
+    private createSpanExporter;
+    /**
+     * Creates a {MetricReader} for pushing metrics out to GCP via OpenTelemetry.
+     */
+    private createMetricReader;
+    /** Gets all open telemetry instrumentations as configured by the plugin. */
+    private getInstrumentations;
+    private shouldExportTraces;
+    private shouldExportMetrics;
+    /** Always configure the Pino and Winston instrumentations */
+    private getDefaultLoggingInstrumentations;
+    private buildMetricExporter;
+}
+/** @hidden */
+declare function __getMetricExporterForTesting(): InMemoryMetricExporter;
+/** @hidden */
+declare function __getSpanExporterForTesting(): InMemorySpanExporter;
+/** @hidden */
+declare function __forceFlushSpansForTesting(): void;
+
+export { GcpOpenTelemetry, __forceFlushSpansForTesting, __getMetricExporterForTesting, __getSpanExporterForTesting };

package/lib/gcpOpenTelemetry.d.ts

@@ -0,0 +1,59 @@
+import { InMemoryMetricExporter } from '@opentelemetry/sdk-metrics';
+import { NodeSDKConfiguration } from '@opentelemetry/sdk-node';
+import { InMemorySpanExporter } from '@opentelemetry/sdk-trace-base';
+import { GcpTelemetryConfig } from './types.js';
+import '@opentelemetry/auto-instrumentations-node';
+import '@opentelemetry/instrumentation';
+import 'google-auth-library';
+
+/**
+ * Copyright 2024 Google LLC
+ *
+ * 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.
+ */
+
+/**
+ * Provides a {TelemetryConfig} for exporting OpenTelemetry data (Traces,
+ * Metrics, and Logs) to the Google Cloud Operations Suite.
+ */
+declare class GcpOpenTelemetry {
+    private readonly config;
+    private readonly resource;
+    constructor(config: GcpTelemetryConfig);
+    /**
+     * Log hook for writing trace and span metadata to log messages in the format
+     * required by GCP.
+     */
+    private gcpTraceLogHook;
+    getConfig(): Promise<Partial<NodeSDKConfiguration>>;
+    private createSpanExporter;
+    /**
+     * Creates a {MetricReader} for pushing metrics out to GCP via OpenTelemetry.
+     */
+    private createMetricReader;
+    /** Gets all open telemetry instrumentations as configured by the plugin. */
+    private getInstrumentations;
+    private shouldExportTraces;
+    private shouldExportMetrics;
+    /** Always configure the Pino and Winston instrumentations */
+    private getDefaultLoggingInstrumentations;
+    private buildMetricExporter;
+}
+/** @hidden */
+declare function __getMetricExporterForTesting(): InMemoryMetricExporter;
+/** @hidden */
+declare function __getSpanExporterForTesting(): InMemorySpanExporter;
+/** @hidden */
+declare function __forceFlushSpansForTesting(): void;
+
+export { GcpOpenTelemetry, __forceFlushSpansForTesting, __getMetricExporterForTesting, __getSpanExporterForTesting };

package/lib/gcpOpenTelemetry.js

@@ -0,0 +1,374 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var gcpOpenTelemetry_exports = {};
+__export(gcpOpenTelemetry_exports, {
+  GcpOpenTelemetry: () => GcpOpenTelemetry,
+  __forceFlushSpansForTesting: () => __forceFlushSpansForTesting,
+  __getMetricExporterForTesting: () => __getMetricExporterForTesting,
+  __getSpanExporterForTesting: () => __getSpanExporterForTesting
+});
+module.exports = __toCommonJS(gcpOpenTelemetry_exports);
+var import_opentelemetry_cloud_monitoring_exporter = require("@google-cloud/opentelemetry-cloud-monitoring-exporter");
+var import_opentelemetry_cloud_trace_exporter = require("@google-cloud/opentelemetry-cloud-trace-exporter");
+var import_opentelemetry_resource_util = require("@google-cloud/opentelemetry-resource-util");
+var import_api = require("@opentelemetry/api");
+var import_auto_instrumentations_node = require("@opentelemetry/auto-instrumentations-node");
+var import_instrumentation_pino = require("@opentelemetry/instrumentation-pino");
+var import_instrumentation_winston = require("@opentelemetry/instrumentation-winston");
+var import_resources = require("@opentelemetry/resources");
+var import_sdk_metrics = require("@opentelemetry/sdk-metrics");
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_genkit = require("genkit");
+var import_logging = require("genkit/logging");
+var import_action = require("./telemetry/action.js");
+var import_engagement = require("./telemetry/engagement.js");
+var import_feature = require("./telemetry/feature.js");
+var import_generate = require("./telemetry/generate.js");
+var import_path = require("./telemetry/path.js");
+var import_utils = require("./utils.js");
+let metricExporter;
+let spanProcessor;
+let spanExporter;
+class GcpOpenTelemetry {
+  config;
+  resource;
+  constructor(config) {
+    this.config = config;
+    this.resource = new import_resources.Resource({ type: "global" }).merge(
+      new import_opentelemetry_resource_util.GcpDetectorSync().detect()
+    );
+  }
+  /**
+   * Log hook for writing trace and span metadata to log messages in the format
+   * required by GCP.
+   */
+  gcpTraceLogHook = (span, record) => {
+    const spanContext = span.spanContext();
+    const isSampled = !!(spanContext.traceFlags & import_api.TraceFlags.SAMPLED);
+    const projectId = this.config.projectId;
+    record["logging.googleapis.com/trace"] ??= `projects/${projectId}/traces/${spanContext.traceId}`;
+    record["logging.googleapis.com/trace_sampled"] ??= isSampled ? "1" : "0";
+    record["logging.googleapis.com/spanId"] ??= spanContext.spanId;
+    delete record["span_id"];
+    delete record["trace_id"];
+    delete record["trace_flags"];
+  };
+  async getConfig() {
+    spanProcessor = new import_sdk_trace_base.BatchSpanProcessor(await this.createSpanExporter());
+    return {
+      resource: this.resource,
+      spanProcessor,
+      sampler: this.config.sampler,
+      instrumentations: this.getInstrumentations(),
+      metricReader: await this.createMetricReader()
+    };
+  }
+  async createSpanExporter() {
+    spanExporter = new AdjustingTraceExporter(
+      this.shouldExportTraces() ? new import_opentelemetry_cloud_trace_exporter.TraceExporter({
+        // provided projectId should take precedence over env vars, etc
+        projectId: this.config.projectId,
+        // creds for non-GCP environments, in lieu of using ADC.
+        credentials: this.config.credentials
+      }) : new import_sdk_trace_base.InMemorySpanExporter(),
+      this.config.exportInputAndOutput,
+      this.config.projectId,
+      getErrorHandler(
+        (err) => {
+          return (0, import_utils.tracingDenied)(err);
+        },
+        await (0, import_utils.tracingDeniedHelpText)()
+      )
+    );
+    return spanExporter;
+  }
+  /**
+   * Creates a {MetricReader} for pushing metrics out to GCP via OpenTelemetry.
+   */
+  async createMetricReader() {
+    metricExporter = await this.buildMetricExporter();
+    return new import_sdk_metrics.PeriodicExportingMetricReader({
+      exportIntervalMillis: this.config.metricExportIntervalMillis,
+      exportTimeoutMillis: this.config.metricExportTimeoutMillis,
+      exporter: metricExporter
+    });
+  }
+  /** Gets all open telemetry instrumentations as configured by the plugin. */
+  getInstrumentations() {
+    let instrumentations = [];
+    if (this.config.autoInstrumentation) {
+      instrumentations = (0, import_auto_instrumentations_node.getNodeAutoInstrumentations)(
+        this.config.autoInstrumentationConfig
+      );
+    }
+    return instrumentations.concat(this.getDefaultLoggingInstrumentations()).concat(this.config.instrumentations ?? []);
+  }
+  shouldExportTraces() {
+    return this.config.export && !this.config.disableTraces;
+  }
+  shouldExportMetrics() {
+    return this.config.export && !this.config.disableMetrics;
+  }
+  /** Always configure the Pino and Winston instrumentations */
+  getDefaultLoggingInstrumentations() {
+    return [
+      new import_instrumentation_winston.WinstonInstrumentation({ logHook: this.gcpTraceLogHook }),
+      new import_instrumentation_pino.PinoInstrumentation({ logHook: this.gcpTraceLogHook })
+    ];
+  }
+  async buildMetricExporter() {
+    const exporter = this.shouldExportMetrics() ? new MetricExporterWrapper(
+      {
+        userAgent: {
+          product: "genkit",
+          version: import_genkit.GENKIT_VERSION
+        },
+        // provided projectId should take precedence over env vars, etc
+        projectId: this.config.projectId,
+        // creds for non-GCP environments, in lieu of using ADC.
+        credentials: this.config.credentials
+      },
+      getErrorHandler(
+        (err) => {
+          return (0, import_utils.metricsDenied)(err);
+        },
+        await (0, import_utils.metricsDeniedHelpText)()
+      )
+    ) : new import_sdk_metrics.InMemoryMetricExporter(import_sdk_metrics.AggregationTemporality.DELTA);
+    return exporter;
+  }
+}
+class MetricExporterWrapper extends import_opentelemetry_cloud_monitoring_exporter.MetricExporter {
+  constructor(options, errorHandler) {
+    super(options);
+    this.errorHandler = errorHandler;
+  }
+  promise = new Promise((resolve) => resolve());
+  async export(metrics, resultCallback) {
+    await this.promise;
+    this.modifyStartTimes(metrics);
+    this.promise = new Promise((resolve) => {
+      super.export(metrics, (result) => {
+        try {
+          if (this.errorHandler && result.error) {
+            this.errorHandler(result.error);
+          }
+          resultCallback(result);
+        } finally {
+          resolve();
+        }
+      });
+    });
+  }
+  selectAggregation(instrumentType) {
+    if (instrumentType === import_sdk_metrics.InstrumentType.HISTOGRAM) {
+      return new import_sdk_metrics.ExponentialHistogramAggregation();
+    }
+    return new import_sdk_metrics.DefaultAggregation();
+  }
+  selectAggregationTemporality(instrumentType) {
+    return import_sdk_metrics.AggregationTemporality.DELTA;
+  }
+  /**
+   * Modify the start times of each data point to ensure no
+   * overlap with previous exports.
+   *
+   * Cloud metrics do not support delta metrics for custom metrics
+   * and will convert any DELTA aggregations to CUMULATIVE ones on
+   * export. There is implicit overlap in the start/end times that
+   * the Metric reader is sending -- the end_time of the previous
+   * export will become the start_time of the current export. The
+   * overlap in times means that only one of those records will
+   * persist and the other will be overwritten. This
+   * method adds a thousandth of a second to ensure discrete export
+   * timeframes.
+   */
+  modifyStartTimes(metrics) {
+    metrics.scopeMetrics.forEach((scopeMetric) => {
+      scopeMetric.metrics.forEach((metric) => {
+        metric.dataPoints.forEach((dataPoint) => {
+          dataPoint.startTime[1] = dataPoint.startTime[1] + 1e6;
+        });
+      });
+    });
+  }
+  async shutdown() {
+    return await this.forceFlush();
+  }
+  async forceFlush() {
+    await this.promise;
+  }
+}
+class AdjustingTraceExporter {
+  constructor(exporter, logInputAndOutput, projectId, errorHandler) {
+    this.exporter = exporter;
+    this.logInputAndOutput = logInputAndOutput;
+    this.projectId = projectId;
+    this.errorHandler = errorHandler;
+  }
+  export(spans, resultCallback) {
+    this.exporter?.export(this.adjust(spans), (result) => {
+      if (this.errorHandler && result.error) {
+        this.errorHandler(result.error);
+      }
+      resultCallback(result);
+    });
+  }
+  shutdown() {
+    return this.exporter?.shutdown();
+  }
+  getExporter() {
+    return this.exporter;
+  }
+  forceFlush() {
+    if (this.exporter?.forceFlush) {
+      return this.exporter.forceFlush();
+    }
+    return Promise.resolve();
+  }
+  adjust(spans) {
+    return spans.map((span) => {
+      this.tickTelemetry(span);
+      span = this.redactInputOutput(span);
+      span = this.markErrorSpanAsError(span);
+      span = this.markFailedSpan(span);
+      span = this.markGenkitFeature(span);
+      span = this.markGenkitModel(span);
+      span = this.normalizeLabels(span);
+      return span;
+    });
+  }
+  tickTelemetry(span) {
+    const attributes = span.attributes;
+    if (!Object.keys(attributes).includes("genkit:type")) {
+      return;
+    }
+    const type = attributes["genkit:type"];
+    const subtype = attributes["genkit:metadata:subtype"];
+    const isRoot = !!span.attributes["genkit:isRoot"];
+    import_path.pathsTelemetry.tick(span, this.logInputAndOutput, this.projectId);
+    if (isRoot) {
+      import_feature.featuresTelemetry.tick(span, this.logInputAndOutput, this.projectId);
+      span.attributes["genkit:rootState"] = span.attributes["genkit:state"];
+    } else {
+      if (type === "action" && subtype === "model") {
+        import_generate.generateTelemetry.tick(span, this.logInputAndOutput, this.projectId);
+      }
+      if (type === "action" && subtype === "tool") {
+      }
+      if (type === "action" || type === "flow" || type == "flowStep" || type == "util") {
+        import_action.actionTelemetry.tick(span, this.logInputAndOutput, this.projectId);
+      }
+    }
+    if (type === "userEngagement") {
+      import_engagement.engagementTelemetry.tick(span, this.logInputAndOutput, this.projectId);
+    }
+  }
+  redactInputOutput(span) {
+    const hasInput = "genkit:input" in span.attributes;
+    const hasOutput = "genkit:output" in span.attributes;
+    return !hasInput && !hasOutput ? span : {
+      ...span,
+      spanContext: span.spanContext,
+      attributes: {
+        ...span.attributes,
+        "genkit:input": "<redacted>",
+        "genkit:output": "<redacted>"
+      }
+    };
+  }
+  // This is a workaround for GCP Trace to mark a span with a red
+  // exclamation mark indicating that it is an error.
+  markErrorSpanAsError(span) {
+    return span.status.code !== import_api.SpanStatusCode.ERROR ? span : {
+      ...span,
+      spanContext: span.spanContext,
+      attributes: {
+        ...span.attributes,
+        "/http/status_code": "599"
+      }
+    };
+  }
+  normalizeLabels(span) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(span.attributes)) {
+      normalized[key.replace(/\:/g, "/")] = value;
+    }
+    return {
+      ...span,
+      spanContext: span.spanContext,
+      attributes: normalized
+    };
+  }
+  markFailedSpan(span) {
+    if (span.attributes["genkit:isFailureSource"]) {
+      span.attributes["genkit:failedSpan"] = span.attributes["genkit:name"];
+      span.attributes["genkit:failedPath"] = span.attributes["genkit:path"];
+    }
+    return span;
+  }
+  markGenkitFeature(span) {
+    if (span.attributes["genkit:isRoot"] && !!span.attributes["genkit:name"]) {
+      span.attributes["genkit:feature"] = span.attributes["genkit:name"];
+    }
+    return span;
+  }
+  markGenkitModel(span) {
+    if (span.attributes["genkit:metadata:subtype"] === "model" && !!span.attributes["genkit:name"]) {
+      span.attributes["genkit:model"] = span.attributes["genkit:name"];
+    }
+    return span;
+  }
+}
+function getErrorHandler(shouldLogFn, helpText) {
+  let instructionsLogged = false;
+  return (err) => {
+    const defaultLogger = import_logging.logger.defaultLogger;
+    if (err && shouldLogFn(err)) {
+      if (!instructionsLogged) {
+        instructionsLogged = true;
+        defaultLogger.error(
+          `Unable to send telemetry to Google Cloud: ${err.message}
+
+${helpText}
+`
+        );
+      }
+    } else if (err) {
+      defaultLogger.error(`Unable to send telemetry to Google Cloud: ${err}`);
+    }
+  };
+}
+function __getMetricExporterForTesting() {
+  return metricExporter;
+}
+function __getSpanExporterForTesting() {
+  return spanExporter.getExporter();
+}
+function __forceFlushSpansForTesting() {
+  spanProcessor.forceFlush();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GcpOpenTelemetry,
+  __forceFlushSpansForTesting,
+  __getMetricExporterForTesting,
+  __getSpanExporterForTesting
+});
+//# sourceMappingURL=gcpOpenTelemetry.js.map

package/lib/gcpOpenTelemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/gcpOpenTelemetry.ts"],"sourcesContent":["/**\n * Copyright 2024 Google LLC\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 *     http://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  MetricExporter,\n  type ExporterOptions,\n} from '@google-cloud/opentelemetry-cloud-monitoring-exporter';\nimport { TraceExporter } from '@google-cloud/opentelemetry-cloud-trace-exporter';\nimport { GcpDetectorSync } from '@google-cloud/opentelemetry-resource-util';\nimport { SpanStatusCode, TraceFlags, type Span } from '@opentelemetry/api';\nimport { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';\nimport { type ExportResult } from '@opentelemetry/core';\nimport type { Instrumentation } from '@opentelemetry/instrumentation';\nimport { PinoInstrumentation } from '@opentelemetry/instrumentation-pino';\nimport { WinstonInstrumentation } from '@opentelemetry/instrumentation-winston';\nimport { Resource } from '@opentelemetry/resources';\nimport {\n  AggregationTemporality,\n  DefaultAggregation,\n  ExponentialHistogramAggregation,\n  InMemoryMetricExporter,\n  InstrumentType,\n  PeriodicExportingMetricReader,\n  type PushMetricExporter,\n  type ResourceMetrics,\n} from '@opentelemetry/sdk-metrics';\nimport type { NodeSDKConfiguration } from '@opentelemetry/sdk-node';\nimport {\n  BatchSpanProcessor,\n  InMemorySpanExporter,\n  type ReadableSpan,\n  type SpanExporter,\n} from '@opentelemetry/sdk-trace-base';\nimport { GENKIT_VERSION } from 'genkit';\nimport { logger } from 'genkit/logging';\nimport { actionTelemetry } from './telemetry/action.js';\nimport { engagementTelemetry } from './telemetry/engagement.js';\nimport { featuresTelemetry } from './telemetry/feature.js';\nimport { generateTelemetry } from './telemetry/generate.js';\nimport { pathsTelemetry } from './telemetry/path.js';\nimport type { GcpTelemetryConfig } from './types.js';\nimport {\n  metricsDenied,\n  metricsDeniedHelpText,\n  tracingDenied,\n  tracingDeniedHelpText,\n} from './utils.js';\n\nlet metricExporter: PushMetricExporter;\nlet spanProcessor: BatchSpanProcessor;\nlet spanExporter: AdjustingTraceExporter;\n\n/**\n * Provides a {TelemetryConfig} for exporting OpenTelemetry data (Traces,\n * Metrics, and Logs) to the Google Cloud Operations Suite.\n */\nexport class GcpOpenTelemetry {\n  private readonly config: GcpTelemetryConfig;\n  private readonly resource: Resource;\n\n  constructor(config: GcpTelemetryConfig) {\n    this.config = config;\n    this.resource = new Resource({ type: 'global' }).merge(\n      new GcpDetectorSync().detect()\n    );\n  }\n\n  /**\n   * Log hook for writing trace and span metadata to log messages in the format\n   * required by GCP.\n   */\n  private gcpTraceLogHook = (span: Span, record: any) => {\n    const spanContext = span.spanContext();\n    const isSampled = !!(spanContext.traceFlags & TraceFlags.SAMPLED);\n    const projectId = this.config.projectId;\n\n    record['logging.googleapis.com/trace'] ??=\n      `projects/${projectId}/traces/${spanContext.traceId}`;\n    record['logging.googleapis.com/trace_sampled'] ??= isSampled ? '1' : '0';\n    record['logging.googleapis.com/spanId'] ??= spanContext.spanId;\n\n    // Clear out the duplicate trace and span information in the log metadata.\n    // These will be incorrect for logs written during span export time since\n    // the logs are written after the span has fully executed. Those logs are\n    // explicitly tied to the correct span in createCommonLogAttributes in\n    // utils.ts.\n    delete record['span_id'];\n    delete record['trace_id'];\n    delete record['trace_flags'];\n  };\n\n  async getConfig(): Promise<Partial<NodeSDKConfiguration>> {\n    spanProcessor = new BatchSpanProcessor(await this.createSpanExporter());\n    return {\n      resource: this.resource,\n      spanProcessor: spanProcessor,\n      sampler: this.config.sampler,\n      instrumentations: this.getInstrumentations(),\n      metricReader: await this.createMetricReader(),\n    };\n  }\n\n  private async createSpanExporter(): Promise<SpanExporter> {\n    spanExporter = new AdjustingTraceExporter(\n      this.shouldExportTraces()\n        ? new TraceExporter({\n            // provided projectId should take precedence over env vars, etc\n            projectId: this.config.projectId,\n            // creds for non-GCP environments, in lieu of using ADC.\n            credentials: this.config.credentials,\n          })\n        : new InMemorySpanExporter(),\n      this.config.exportInputAndOutput,\n      this.config.projectId,\n      getErrorHandler(\n        (err) => {\n          return tracingDenied(err);\n        },\n        await tracingDeniedHelpText()\n      )\n    );\n    return spanExporter;\n  }\n\n  /**\n   * Creates a {MetricReader} for pushing metrics out to GCP via OpenTelemetry.\n   */\n  private async createMetricReader(): Promise<PeriodicExportingMetricReader> {\n    metricExporter = await this.buildMetricExporter();\n    return new PeriodicExportingMetricReader({\n      exportIntervalMillis: this.config.metricExportIntervalMillis,\n      exportTimeoutMillis: this.config.metricExportTimeoutMillis,\n      exporter: metricExporter,\n    });\n  }\n\n  /** Gets all open telemetry instrumentations as configured by the plugin. */\n  private getInstrumentations() {\n    let instrumentations: Instrumentation[] = [];\n\n    if (this.config.autoInstrumentation) {\n      instrumentations = getNodeAutoInstrumentations(\n        this.config.autoInstrumentationConfig\n      );\n    }\n\n    return instrumentations\n      .concat(this.getDefaultLoggingInstrumentations())\n      .concat(this.config.instrumentations ?? []);\n  }\n\n  private shouldExportTraces(): boolean {\n    return this.config.export && !this.config.disableTraces;\n  }\n\n  private shouldExportMetrics(): boolean {\n    return this.config.export && !this.config.disableMetrics;\n  }\n\n  /** Always configure the Pino and Winston instrumentations */\n  private getDefaultLoggingInstrumentations(): Instrumentation[] {\n    return [\n      new WinstonInstrumentation({ logHook: this.gcpTraceLogHook }),\n      new PinoInstrumentation({ logHook: this.gcpTraceLogHook }),\n    ];\n  }\n\n  private async buildMetricExporter(): Promise<PushMetricExporter> {\n    const exporter: PushMetricExporter = this.shouldExportMetrics()\n      ? new MetricExporterWrapper(\n          {\n            userAgent: {\n              product: 'genkit',\n              version: GENKIT_VERSION,\n            },\n            // provided projectId should take precedence over env vars, etc\n            projectId: this.config.projectId,\n            // creds for non-GCP environments, in lieu of using ADC.\n            credentials: this.config.credentials,\n          },\n          getErrorHandler(\n            (err) => {\n              return metricsDenied(err);\n            },\n            await metricsDeniedHelpText()\n          )\n        )\n      : new InMemoryMetricExporter(AggregationTemporality.DELTA);\n    return exporter;\n  }\n}\n\n/**\n * Rewrites the export method to include an error handler which logs\n * helpful information about how to set up metrics/telemetry in GCP.\n */\nclass MetricExporterWrapper extends MetricExporter {\n  private promise = new Promise<void>((resolve) => resolve());\n\n  constructor(\n    options?: ExporterOptions,\n    private errorHandler?: (error: Error) => void\n  ) {\n    super(options);\n  }\n\n  async export(\n    metrics: ResourceMetrics,\n    resultCallback: (result: ExportResult) => void\n  ): Promise<void> {\n    await this.promise;\n    this.modifyStartTimes(metrics);\n    this.promise = new Promise<void>((resolve) => {\n      super.export(metrics, (result) => {\n        try {\n          if (this.errorHandler && result.error) {\n            this.errorHandler(result.error);\n          }\n          resultCallback(result);\n        } finally {\n          resolve();\n        }\n      });\n    });\n  }\n\n  selectAggregation(instrumentType: InstrumentType) {\n    if (instrumentType === InstrumentType.HISTOGRAM) {\n      return new ExponentialHistogramAggregation();\n    }\n    return new DefaultAggregation();\n  }\n\n  selectAggregationTemporality(instrumentType: InstrumentType) {\n    return AggregationTemporality.DELTA;\n  }\n\n  /**\n   * Modify the start times of each data point to ensure no\n   * overlap with previous exports.\n   *\n   * Cloud metrics do not support delta metrics for custom metrics\n   * and will convert any DELTA aggregations to CUMULATIVE ones on\n   * export. There is implicit overlap in the start/end times that\n   * the Metric reader is sending -- the end_time of the previous\n   * export will become the start_time of the current export. The\n   * overlap in times means that only one of those records will\n   * persist and the other will be overwritten. This\n   * method adds a thousandth of a second to ensure discrete export\n   * timeframes.\n   */\n  private modifyStartTimes(metrics: ResourceMetrics): void {\n    metrics.scopeMetrics.forEach((scopeMetric) => {\n      scopeMetric.metrics.forEach((metric) => {\n        metric.dataPoints.forEach((dataPoint) => {\n          dataPoint.startTime[1] = dataPoint.startTime[1] + 1_000_000;\n        });\n      });\n    });\n  }\n\n  async shutdown(): Promise<void> {\n    return await this.forceFlush();\n  }\n\n  async forceFlush(): Promise<void> {\n    await this.promise;\n  }\n}\n\n/**\n * Adjusts spans before exporting to GCP. Redacts model input\n * and output content, and augments span attributes before sending to GCP.\n */\nclass AdjustingTraceExporter implements SpanExporter {\n  constructor(\n    private exporter: SpanExporter,\n    private logInputAndOutput: boolean,\n    private projectId?: string,\n    private errorHandler?: (error: Error) => void\n  ) {}\n\n  export(\n    spans: ReadableSpan[],\n    resultCallback: (result: ExportResult) => void\n  ): void {\n    this.exporter?.export(this.adjust(spans), (result) => {\n      if (this.errorHandler && result.error) {\n        this.errorHandler(result.error);\n      }\n      resultCallback(result);\n    });\n  }\n\n  shutdown(): Promise<void> {\n    return this.exporter?.shutdown();\n  }\n\n  getExporter(): SpanExporter {\n    return this.exporter;\n  }\n\n  forceFlush(): Promise<void> {\n    if (this.exporter?.forceFlush) {\n      return this.exporter.forceFlush();\n    }\n    return Promise.resolve();\n  }\n\n  private adjust(spans: ReadableSpan[]): ReadableSpan[] {\n    return spans.map((span) => {\n      this.tickTelemetry(span);\n\n      span = this.redactInputOutput(span);\n      span = this.markErrorSpanAsError(span);\n      span = this.markFailedSpan(span);\n      span = this.markGenkitFeature(span);\n      span = this.markGenkitModel(span);\n      span = this.normalizeLabels(span);\n      return span;\n    });\n  }\n\n  private tickTelemetry(span: ReadableSpan) {\n    const attributes = span.attributes;\n    if (!Object.keys(attributes).includes('genkit:type')) {\n      return;\n    }\n\n    const type = attributes['genkit:type'] as string;\n    const subtype = attributes['genkit:metadata:subtype'] as string;\n    const isRoot = !!span.attributes['genkit:isRoot'];\n\n    pathsTelemetry.tick(span, this.logInputAndOutput, this.projectId);\n    if (isRoot) {\n      // Report top level feature request and latency only for root spans\n      // Log input to and output from to the feature\n      featuresTelemetry.tick(span, this.logInputAndOutput, this.projectId);\n      // Set root status explicitly\n      span.attributes['genkit:rootState'] = span.attributes['genkit:state'];\n    } else {\n      if (type === 'action' && subtype === 'model') {\n        // Report generate metrics () for all model actions\n        generateTelemetry.tick(span, this.logInputAndOutput, this.projectId);\n      }\n      if (type === 'action' && subtype === 'tool') {\n        // TODO: Report input and output for tool actions\n      }\n      if (\n        type === 'action' ||\n        type === 'flow' ||\n        type == 'flowStep' ||\n        type == 'util'\n      ) {\n        // Report request and latency metrics for all actions\n        actionTelemetry.tick(span, this.logInputAndOutput, this.projectId);\n      }\n    }\n    if (type === 'userEngagement') {\n      // Report user acceptance and feedback metrics\n      engagementTelemetry.tick(span, this.logInputAndOutput, this.projectId);\n    }\n  }\n\n  private redactInputOutput(span: ReadableSpan): ReadableSpan {\n    const hasInput = 'genkit:input' in span.attributes;\n    const hasOutput = 'genkit:output' in span.attributes;\n\n    return !hasInput && !hasOutput\n      ? span\n      : {\n          ...span,\n          spanContext: span.spanContext,\n          attributes: {\n            ...span.attributes,\n            'genkit:input': '<redacted>',\n            'genkit:output': '<redacted>',\n          },\n        };\n  }\n\n  // This is a workaround for GCP Trace to mark a span with a red\n  // exclamation mark indicating that it is an error.\n  private markErrorSpanAsError(span: ReadableSpan): ReadableSpan {\n    return span.status.code !== SpanStatusCode.ERROR\n      ? span\n      : {\n          ...span,\n          spanContext: span.spanContext,\n          attributes: {\n            ...span.attributes,\n            '/http/status_code': '599',\n          },\n        };\n  }\n\n  private normalizeLabels(span: ReadableSpan): ReadableSpan {\n    const normalized = {} as Record<string, any>;\n    for (const [key, value] of Object.entries(span.attributes)) {\n      normalized[key.replace(/\\:/g, '/')] = value;\n    }\n    return {\n      ...span,\n      spanContext: span.spanContext,\n      attributes: normalized,\n    };\n  }\n\n  private markFailedSpan(span: ReadableSpan): ReadableSpan {\n    if (span.attributes['genkit:isFailureSource']) {\n      span.attributes['genkit:failedSpan'] = span.attributes['genkit:name'];\n      span.attributes['genkit:failedPath'] = span.attributes['genkit:path'];\n    }\n    return span;\n  }\n\n  private markGenkitFeature(span: ReadableSpan): ReadableSpan {\n    if (span.attributes['genkit:isRoot'] && !!span.attributes['genkit:name']) {\n      span.attributes['genkit:feature'] = span.attributes['genkit:name'];\n    }\n    return span;\n  }\n\n  private markGenkitModel(span: ReadableSpan): ReadableSpan {\n    if (\n      span.attributes['genkit:metadata:subtype'] === 'model' &&\n      !!span.attributes['genkit:name']\n    ) {\n      span.attributes['genkit:model'] = span.attributes['genkit:name'];\n    }\n    return span;\n  }\n}\n\nfunction getErrorHandler(\n  shouldLogFn: (err: Error) => boolean,\n  helpText: string\n): (err: Error) => void {\n  // only log the first time\n  let instructionsLogged = false;\n\n  return (err) => {\n    // Use the defaultLogger so that logs don't get swallowed by the open\n    // telemetry exporter\n    const defaultLogger = logger.defaultLogger;\n    if (err && shouldLogFn(err)) {\n      if (!instructionsLogged) {\n        instructionsLogged = true;\n        defaultLogger.error(\n          `Unable to send telemetry to Google Cloud: ${err.message}\\n\\n${helpText}\\n`\n        );\n      }\n    } else if (err) {\n      defaultLogger.error(`Unable to send telemetry to Google Cloud: ${err}`);\n    }\n  };\n}\n\n/** @hidden */\nexport function __getMetricExporterForTesting(): InMemoryMetricExporter {\n  return metricExporter as InMemoryMetricExporter;\n}\n\n/** @hidden */\nexport function __getSpanExporterForTesting(): InMemorySpanExporter {\n  return spanExporter.getExporter() as InMemorySpanExporter;\n}\n\n/** @hidden */\nexport function __forceFlushSpansForTesting() {\n  spanProcessor.forceFlush();\n}\n"],"mappings":"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","names":[]}