rework how sentry metrics are collected

Author: nsdeschenes

packages/bundler-plugin-core/src/bundle-analysis/bundleAnalysisPluginFactory.ts

@@ -8,23 +8,23 @@ import {
 import { type UnpluginContextMeta, type UnpluginOptions } from "unplugin";
 import { getPreSignedURL } from "../utils/getPreSignedURL.ts";
 import { uploadStats } from "../utils/uploadStats.ts";
-import { type SentryClient } from "../sentry.ts";
+import { type SentryMetrics } from "../sentry.ts";
 import { type NormalizedOptions } from "../utils/normalizeOptions.ts";
 import { createGauge } from "../utils/fetchWithRetry.ts";
 
 interface BundleAnalysisUploadPluginArgs {
   userOptions: NormalizedOptions;
   unpluginMetaContext: UnpluginContextMeta;
   bundleAnalysisUploadPlugin: BundleAnalysisUploadPlugin;
-  sentryClient: SentryClient;
+  sentryMetrics: SentryMetrics;
   handleRecoverableError: (error: unknown) => void;
 }
 
 export const bundleAnalysisPluginFactory = ({
   userOptions,
   unpluginMetaContext,
   bundleAnalysisUploadPlugin,
-  sentryClient,
+  sentryMetrics,
   handleRecoverableError,
 }: BundleAnalysisUploadPluginArgs): UnpluginOptions => {
   const output: Output = {
@@ -66,7 +66,7 @@ export const bundleAnalysisPluginFactory = ({
       let url = "";
       const gauge = createGauge({
         bundler: unpluginMetaContext.framework,
-        sentryClient,
+        sentryMetrics,
       });
       const getPreSignedURLStart = Date.now();
       try {
@@ -77,27 +77,18 @@ export const bundleAnalysisPluginFactory = ({
           retryCount: userOptions?.retryCount,
           gauge,
         });
-        sentryClient?.metricsAggregator?.add(
-          "c",
-          "request_presigned_url.success",
-          1,
-          "none",
-          { bundler: unpluginMetaContext.framework },
-        );
+        sentryMetrics?.increment("request_presigned_url.success", 1, "none", {
+          bundler: unpluginMetaContext.framework,
+        });
       } catch (error) {
-        sentryClient?.metricsAggregator?.add(
-          "c",
-          "request_presigned_url.error",
-          1,
-          "none",
-          { bundler: unpluginMetaContext.framework },
-        );
+        sentryMetrics?.increment("request_presigned_url.error", 1, "none", {
+          bundler: unpluginMetaContext.framework,
+        });
 
         handleRecoverableError(error);
         return;
       } finally {
-        sentryClient?.metricsAggregator?.add(
-          "d",
+        sentryMetrics?.distribution(
           "request_presigned_url",
           Date.now() - getPreSignedURLStart,
           "millisecond",
@@ -113,24 +104,15 @@ export const bundleAnalysisPluginFactory = ({
           retryCount: userOptions?.retryCount,
           gauge,
         });
-        sentryClient?.metricsAggregator?.add(
-          "c",
-          "upload_bundle_stats.success",
-          1,
-          "none",
-          { bundler: unpluginMetaContext.framework },
-        );
+        sentryMetrics?.increment("upload_bundle_stats.success", 1, "none", {
+          bundler: unpluginMetaContext.framework,
+        });
       } catch (error) {
-        sentryClient?.metricsAggregator?.add(
-          "c",
-          "upload_bundle_stats.error",
-          1,
-        );
+        sentryMetrics?.increment("upload_bundle_stats.error", 1);
         handleRecoverableError(error);
         return;
       } finally {
-        sentryClient?.metricsAggregator?.add(
-          "d",
+        sentryMetrics?.distribution(
           "upload_bundle_stats",
           Date.now() - uploadStart,
           "millisecond",

packages/bundler-plugin-core/src/index.ts

@@ -42,7 +42,7 @@ function codecovUnpluginFactory({
 
     const options = normalizeOptions(userOptions);
 
-    const { sentryClient, sentryHub } = createSentryInstance(
+    const { sentryHub, sentryMetrics } = createSentryInstance(
       options,
       unpluginMetaContext.framework,
     );
@@ -90,7 +90,7 @@ function codecovUnpluginFactory({
           userOptions: options,
           unpluginMetaContext,
           bundleAnalysisUploadPlugin,
-          sentryClient,
+          sentryMetrics,
           handleRecoverableError,
         }),
       );

packages/bundler-plugin-core/src/sentry.ts

@@ -7,19 +7,28 @@ import {
 } from "@sentry/node";
 import { type Options } from "./types";
 import { type NormalizedOptions } from "./utils/normalizeOptions";
+import { type Primitive } from "zod";
 
 export type SentryClient = ReturnType<
   typeof createSentryInstance
 >["sentryClient"];
 
+export type SentryMetrics = ReturnType<
+  typeof createSentryInstance
+>["sentryMetrics"];
+
 export const createSentryInstance = (
   options: NormalizedOptions,
   bundler: string,
 ) => {
   const telemetry = options.telemetry ?? true;
 
   if (telemetry === false || !!options.dryRun) {
-    return { sentryClient: undefined, sentryHub: undefined };
+    return {
+      sentryClient: undefined,
+      sentryHub: undefined,
+      sentryMetrics: undefined,
+    };
   }
 
   const client = new NodeClient({
@@ -75,7 +84,30 @@ export const createSentryInstance = (
   // increment the counter for the bundler
   client.metricsAggregator?.add("c", `bundler-${bundler}`, 1);
 
-  return { sentryClient: client, sentryHub: hub };
+  type MetricFunction = (
+    key: string,
+    value: number,
+    unit?: string,
+    tags?: Record<string, Primitive>,
+  ) => void;
+
+  const gauge: MetricFunction = (key, value, unit, tags) =>
+    client.metricsAggregator?.add("g", key, value, unit, tags);
+  const distribution: MetricFunction = (key, value, unit, tags) =>
+    client.metricsAggregator?.add("d", key, value, unit, tags);
+  const increment: MetricFunction = (key, value, unit, tags) =>
+    client.metricsAggregator?.add("c", key, value, unit, tags);
+  const set: MetricFunction = (key, value, unit, tags) =>
+    client.metricsAggregator?.add("s", key, value, unit, tags);
+
+  const sentryMetrics = {
+    distribution,
+    increment,
+    gauge,
+    set,
+  };
+
+  return { sentryClient: client, sentryHub: hub, sentryMetrics };
 };
 
 export const setTelemetryDataOnHub = (

packages/bundler-plugin-core/src/utils/fetchWithRetry.ts

@@ -1,20 +1,20 @@
-import { type SentryClient } from "../sentry.ts";
+import { type SentryMetrics } from "../sentry.ts";
 import { BadResponseError } from "../errors/BadResponseError";
 import { DEFAULT_RETRY_DELAY } from "./constants";
 import { delay } from "./delay";
 import { debug, red } from "./logging";
 
 interface CreateGaugeArgs {
   bundler: string;
-  sentryClient: SentryClient;
+  sentryMetrics: SentryMetrics;
 }
 
 export type Gauge = ReturnType<typeof createGauge>;
 
 export const createGauge =
-  ({ bundler, sentryClient }: CreateGaugeArgs) =>
+  ({ bundler, sentryMetrics }: CreateGaugeArgs) =>
   (name: string, count: number) => {
-    sentryClient?.metricsAggregator?.add("g", `fetch.${name}`, count, "none", {
+    sentryMetrics?.gauge(`fetch.${name}`, count, "none", {
       bundler,
     });
   };