(feat) Reorganize and improve crashlytics tools (#9127)

- Importing interfaces for the Crashlytics public API
- Setting appropriate return types in client responses
- When retrieving native crash sessions, pruning all superfluous threads
  to dramatically reduce token usage.
- Providing schemas for comprehensive filtering options
- Consoldidating report client calls into a single method
- Consolidating tool definitions and sharing schema defs

Author: maxl0rd

src/crashlytics/addNote.spec.ts

@@ -0,0 +1,85 @@
+import * as chai from "chai";
+import * as nock from "nock";
+import * as chaiAsPromised from "chai-as-promised";
+
+import { listEvents } from "./events";
+import { FirebaseError } from "../error";
+import { crashlyticsApiOrigin } from "../api";
+
+chai.use(chaiAsPromised);
+const expect = chai.expect;
+
+describe("events", () => {
+  const appId = "1:1234567890:android:abcdef1234567890";
+  const requestProjectNumber = "1234567890";
+  const issueId = "test_issue_id";
+  const variantId = "test_variant_id";
+  const pageSize = 2;
+
+  afterEach(() => {
+    nock.cleanAll();
+  });
+
+  describe("listEvents", () => {
+    it("should resolve with the response body on success", async () => {
+      const mockResponse = { events: [{ event_id: "1" }] };
+
+      nock(crashlyticsApiOrigin())
+        .get(`/v1alpha/projects/${requestProjectNumber}/apps/${appId}/events`)
+        .query({
+          "filter.issue.id": issueId,
+          page_size: String(pageSize),
+        })
+        .reply(200, mockResponse);
+
+      const result = await listEvents(appId, { issueId: issueId }, pageSize);
+
+      expect(result).to.deep.equal(mockResponse);
+      expect(nock.isDone()).to.be.true;
+    });
+
+    it("should resolve with the response body on success with variantId", async () => {
+      const mockResponse = { events: [{ event_id: "1" }] };
+
+      nock(crashlyticsApiOrigin())
+        .get(`/v1alpha/projects/${requestProjectNumber}/apps/${appId}/events`)
+        .query({
+          "filter.issue.id": issueId,
+          "filter.issue.variant_id": variantId,
+          page_size: String(pageSize),
+        })
+        .reply(200, mockResponse);
+
+      const result = await listEvents(
+        appId,
+        { issueId: issueId, issueVariantId: variantId },
+        pageSize,
+      );
+
+      expect(result).to.deep.equal(mockResponse);
+      expect(nock.isDone()).to.be.true;
+    });
+
+    it("should throw a FirebaseError if the API call fails", async () => {
+      nock(crashlyticsApiOrigin())
+        .get(`/v1alpha/projects/${requestProjectNumber}/apps/${appId}/events`)
+        .query({
+          page_size: String(pageSize),
+        })
+        .reply(500, { error: "Internal Server Error" });
+
+      await expect(listEvents(appId, {}, pageSize)).to.be.rejectedWith(
+        FirebaseError,
+        `Failed to list events for app_id ${appId}.`,
+      );
+    });
+
+    it("should throw a FirebaseError if the appId is invalid", async () => {
+      const invalidAppId = "invalid-app-id";
+
+      await expect(
+        listEvents(invalidAppId, { issueId: issueId, issueVariantId: variantId }),
+      ).to.be.rejectedWith(FirebaseError, "Unable to get the projectId from the AppId.");
+    });
+  });
+});

src/crashlytics/addNote.ts

@@ -0,0 +1,45 @@
+import { logger } from "../logger";
+import { FirebaseError, getError } from "../error";
+import { CRASHLYTICS_API_CLIENT, parseProjectNumber, TIMEOUT } from "./utils";
+import { ListEventsResponse } from "./types";
+import { EventFilter, filterToUrlSearchParams } from "./filters";
+
+/**
+ * List Crashlytics events matching the given filters.
+ * @param appId Firebase app_id
+ * @param filter An optional EventFilter to selectively filter the sample events.
+ * @param pageSize optional, number of events to return
+ * @return A ListEventsResponse containing the most recent events matching the filters.
+ */
+export async function listEvents(
+  appId: string,
+  filter: EventFilter,
+  pageSize = 1,
+): Promise<ListEventsResponse> {
+  const requestProjectNumber = parseProjectNumber(appId);
+
+  try {
+    const queryParams = filterToUrlSearchParams(filter);
+    queryParams.set("page_size", `${pageSize}`);
+
+    logger.debug(
+      `[crashlytics] listEvents called with appId: ${appId}, filter: ${queryParams.toString()}, pageSize: ${pageSize}`,
+    );
+
+    const response = await CRASHLYTICS_API_CLIENT.request<void, ListEventsResponse>({
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      path: `/projects/${requestProjectNumber}/apps/${appId}/events`,
+      queryParams: queryParams,
+      timeout: TIMEOUT,
+    });
+
+    return response.body;
+  } catch (err: unknown) {
+    throw new FirebaseError(`Failed to list events for app_id ${appId}.`, {
+      original: getError(err),
+    });
+  }
+}

src/crashlytics/deleteNote.spec.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+
+export const ApplicationIdSchema = z
+  .string()
+  .describe(
+    "Firebase app id. For an Android application, read the " +
+      "mobilesdk_app_id value specified in the google-services.json file for " +
+      "the current package name. For an iOS Application, read the GOOGLE_APP_ID " +
+      "from GoogleService-Info.plist. If neither is available, ask the user to " +
+      "provide the app id.",
+  );
+
+export const IssueIdSchema = z.string().describe("Crashlytics issue id, as hexidecimal uuid");
+
+export const EventFilterSchema = z
+  .object({
+    intervalStartTime: z.string().optional().describe(`A timestamp in ISO 8601 string format`),
+    intervalEndTime: z.string().optional().describe(`A timestamp in ISO 8601 string format.`),
+    versionDisplayNames: z
+      .array(z.string())
+      .optional()
+      .describe(`The version display names should be obtained from an API response.`),
+    issueId: z.string().optional().describe(`Count events for the given issue`),
+    issueVariantId: z.string().optional().describe(`Count events for the given issue variant`),
+    issueErrorTypes: z
+      .array(z.enum(["FATAL", "NON_FATAL", "ANR"]))
+      .optional()
+      .describe(
+        `Count FATAL events (crashes), NON_FATAL events (exceptions) or ANR events (application not responding)`,
+      ),
+    issueSignals: z
+      .array(z.enum(["SIGNAL_EARLY", "SIGNAL_FRESH", "SIGNAL_REGRESSED", "SIGNAL_REPETITIVE"]))
+      .optional()
+      .describe(`Count events matching the given signals`),
+    operatingSystemDisplayNames: z
+      .array(z.string())
+      .optional()
+      .describe(`The operating system displayNames should be obtained from an API response`),
+    deviceDisplayNames: z
+      .array(z.string())
+      .optional()
+      .describe(`The operating system displayNames should be obtained from an API response`),
+    deviceFormFactors: z
+      .array(z.enum(["PHONE", "TABLET", "DESKTOP", "TV", "WATCH"]))
+      .optional()
+      .describe(`Count events originating from the given device form factors`),
+  })
+  .optional()
+  .describe(`Only events matching the given filters will be counted. All filters are optional. 
+    If setting a time interval, set both intervalStartTime and intervalEndTime.`);
+
+export type EventFilter = z.infer<typeof EventFilterSchema>;
+
+// Most models seem to understand the flattened, camelCase representation better.
+// This maps those strings to the filter params the API expects.
+
+const toolToParamMap: Record<string, string> = {
+  intervalStartTime: "filter.interval.start_time",
+  intervalEndTime: "filter.interval.end_time",
+  versionDisplayNames: "filter.version.display_names",
+  issueId: "filter.issue.id",
+  issueVariantId: "filter.issue.variant_id",
+  issueErrorTypes: "filter.issue.error_types",
+  issueSignals: "filter.issue.signals",
+  operatingSystemDisplayNames: "filter.operating_system.display_names",
+  deviceDisplayNames: "filter.device.display_names",
+  deviceFormFactors: "filter.device.form_factors",
+};
+
+/**
+ * Converts the model-friendly, flattened camelCase tool parameters into the
+ * AIP-160 style url parameters for all of the filtering options.
+ * @param filter an EventFilter
+ * @return URLSearchParams for a request to the GetReport endpoint
+ */
+export function filterToUrlSearchParams(filter: EventFilter): URLSearchParams {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(filter || {})) {
+    if (value === undefined) {
+      continue;
+    }
+    const paramKey: string = toolToParamMap[key];
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        params.append(paramKey, v);
+      }
+    } else if (value) {
+      params.set(paramKey, value);
+    }
+  }
+  return params;
+}