swap to using gauge factory function for fetchWithRetry, and add tags for different bundler

Author: nsdeschenes

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

@@ -5,20 +5,23 @@ import {
   type ProviderUtilInputs,
   type UploadOverrides,
 } from "../types.ts";
-import { type UnpluginOptions } from "unplugin";
+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 NormalizedOptions } from "src/utils/normalizeOptions.ts";
+import { type NormalizedOptions } from "../utils/normalizeOptions.ts";
+import { createGauge } from "../utils/fetchWithRetry.ts";
 
 interface BundleAnalysisUploadPluginArgs {
   userOptions: NormalizedOptions;
+  unpluginMetaContext: UnpluginContextMeta;
   bundleAnalysisUploadPlugin: BundleAnalysisUploadPlugin;
   sentryClient: SentryClient;
 }
 
 export const bundleAnalysisPluginFactory = ({
   userOptions,
+  unpluginMetaContext,
   bundleAnalysisUploadPlugin,
   sentryClient,
 }: BundleAnalysisUploadPluginArgs): UnpluginOptions => {
@@ -58,25 +61,34 @@ export const bundleAnalysisPluginFactory = ({
       const inputs: ProviderUtilInputs = { envs, args };
       const provider = await detectProvider(inputs);
 
-      const getPreSignedURLStart = Date.now();
       let url = "";
+      const gauge = createGauge({
+        bundler: unpluginMetaContext.framework,
+        sentryClient,
+      });
+      const getPreSignedURLStart = Date.now();
       try {
         url = await getPreSignedURL({
           apiURL: userOptions?.apiUrl,
           uploadToken: userOptions?.uploadToken,
           serviceParams: provider,
           retryCount: userOptions?.retryCount,
+          gauge,
         });
         sentryClient?.metricsAggregator?.add(
           "c",
           "request_presigned_url.success",
           1,
+          "none",
+          { bundler: unpluginMetaContext.framework },
         );
       } catch (error) {
         sentryClient?.metricsAggregator?.add(
           "c",
           "request_presigned_url.error",
           1,
+          "none",
+          { bundler: unpluginMetaContext.framework },
         );
         return;
       } finally {
@@ -85,6 +97,7 @@ export const bundleAnalysisPluginFactory = ({
           "request_presigned_url",
           Date.now() - getPreSignedURLStart,
           "millisecond",
+          { bundler: unpluginMetaContext.framework },
         );
       }
 
@@ -94,12 +107,14 @@ export const bundleAnalysisPluginFactory = ({
           preSignedUrl: url,
           message: JSON.stringify(output),
           retryCount: userOptions?.retryCount,
-          sentryClient,
+          gauge,
         });
         sentryClient?.metricsAggregator?.add(
           "c",
           "upload_bundle_stats.success",
           1,
+          "none",
+          { bundler: unpluginMetaContext.framework },
         );
       } catch {
         sentryClient?.metricsAggregator?.add(
@@ -114,6 +129,7 @@ export const bundleAnalysisPluginFactory = ({
           "upload_bundle_stats",
           Date.now() - uploadStart,
           "millisecond",
+          { bundler: unpluginMetaContext.framework },
         );
       }
     },

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

@@ -51,6 +51,7 @@ function codecovUnpluginFactory({
       plugins.push(
         bundleAnalysisPluginFactory({
           userOptions: options,
+          unpluginMetaContext,
           bundleAnalysisUploadPlugin,
           sentryClient,
         }),

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

@@ -4,20 +4,35 @@ import { DEFAULT_RETRY_DELAY } from "./constants";
 import { delay } from "./delay";
 import { debug, red } from "./logging";
 
+interface CreateGaugeArgs {
+  bundler: string;
+  sentryClient: SentryClient;
+}
+
+export type Gauge = ReturnType<typeof createGauge>;
+
+export const createGauge =
+  ({ bundler, sentryClient }: CreateGaugeArgs) =>
+  (name: string, count: number) => {
+    sentryClient?.metricsAggregator?.add("g", `fetch.${name}`, count, "none", {
+      bundler,
+    });
+  };
+
 interface FetchWithRetryArgs {
   url: string;
   retryCount: number;
   requestData: RequestInit;
   name?: string;
-  sentryClient?: SentryClient;
+  gauge?: Gauge;
 }
 
 export const fetchWithRetry = async ({
   url,
   retryCount,
   requestData,
   name,
-  sentryClient,
+  gauge,
 }: FetchWithRetryArgs) => {
   let response = new Response(null, { status: 400 });
   let retryCounter = 0;
@@ -43,17 +58,16 @@ export const fetchWithRetry = async ({
         if (!(err instanceof BadResponseError)) {
           throw err;
         }
-
-        sentryClient?.metricsAggregator?.add(
-          "g",
-          `fetch.${name}`,
-          retryCounter,
-        );
+        if (gauge && name) {
+          gauge(name, retryCounter + 1);
+        }
         return response;
       }
     }
   }
 
-  sentryClient?.metricsAggregator?.add("g", `fetch.${name}`, retryCounter);
+  if (gauge && name) {
+    gauge(name, retryCounter + 1);
+  }
   return response;
 };

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

@@ -5,17 +5,16 @@ import { NoUploadTokenError } from "../errors/NoUploadTokenError.ts";
 import { UploadLimitReachedError } from "../errors/UploadLimitReachedError.ts";
 import { type ProviderServiceParams } from "../types.ts";
 import { DEFAULT_RETRY_COUNT } from "./constants.ts";
-import { fetchWithRetry } from "./fetchWithRetry.ts";
+import { type Gauge, fetchWithRetry } from "./fetchWithRetry.ts";
 import { green, red } from "./logging.ts";
 import { preProcessBody } from "./preProcessBody.ts";
-import { type SentryClient } from "../sentry.ts";
 
 interface GetPreSignedURLArgs {
   apiURL: string;
   uploadToken?: string;
   serviceParams: Partial<ProviderServiceParams>;
   retryCount?: number;
-  sentryClient?: SentryClient;
+  gauge?: Gauge;
 }
 
 const PreSignedURLSchema = z.object({
@@ -27,7 +26,7 @@ export const getPreSignedURL = async ({
   uploadToken,
   serviceParams,
   retryCount = DEFAULT_RETRY_COUNT,
-  sentryClient,
+  gauge,
 }: GetPreSignedURLArgs) => {
   if (!uploadToken) {
     red("No upload token found");
@@ -41,7 +40,7 @@ export const getPreSignedURL = async ({
     response = await fetchWithRetry({
       url,
       retryCount,
-      sentryClient,
+      gauge,
       name: "get-pre-signed-url",
       requestData: {
         method: "POST",

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

@@ -2,24 +2,23 @@ import { ReadableStream, TextEncoderStream } from "node:stream/web";
 
 import { FailedUploadError } from "../errors/FailedUploadError";
 import { green, red } from "./logging";
-import { fetchWithRetry } from "./fetchWithRetry";
+import { type Gauge, fetchWithRetry } from "./fetchWithRetry";
 import { DEFAULT_RETRY_COUNT } from "./constants";
 import { UploadLimitReachedError } from "../errors/UploadLimitReachedError";
 import { FailedFetchError } from "../errors/FailedFetchError";
-import { type SentryClient } from "../sentry.ts";
 
 interface UploadStatsArgs {
   message: string;
   preSignedUrl: string;
   retryCount?: number;
-  sentryClient?: SentryClient;
+  gauge?: Gauge;
 }
 
 export async function uploadStats({
   message,
   preSignedUrl,
   retryCount = DEFAULT_RETRY_COUNT,
-  sentryClient,
+  gauge,
 }: UploadStatsArgs) {
   const iterator = message[Symbol.iterator]();
   const stream = new ReadableStream({
@@ -40,7 +39,7 @@ export async function uploadStats({
       url: preSignedUrl,
       retryCount,
       name: "upload-stats",
-      sentryClient,
+      gauge,
       requestData: {
         method: "PUT",
         headers: {