@chirpier/chirpier-js 0.2.1 → 0.4.0

package/src/__tests__/chirpier.test.ts

@@ -1,7 +1,7 @@
 import fs from "fs";
 import os from "os";
 import path from "path";
-import axios from "axios";
+import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios";
 import MockAdapter from "axios-mock-adapter";
 import {
   Client,
@@ -20,6 +20,8 @@ import {
 
 describe("Chirpier SDK", () => {
   afterEach(async () => {
+    jest.useRealTimers();
+    jest.restoreAllMocks();
     await stop();
   });
 
@@ -341,6 +343,203 @@ describe("Chirpier SDK", () => {
       expect(JSON.parse(mock.history.post[0].data)[0].event).toBe("queued.before.flush");
     });
 
+    test("retries network errors", async () => {
+      jest.useFakeTimers();
+      const client: Client = createClient({
+        key: "chp_network_retry_key",
+        retries: 2,
+        flushDelay: 10000,
+      });
+      const axiosBackedClient = client as unknown as { axiosInstance: AxiosInstance };
+      let attempts = 0;
+      axiosBackedClient.axiosInstance.defaults.adapter = async (
+        config: AxiosRequestConfig
+      ): Promise<AxiosResponse> => {
+        attempts += 1;
+        if (attempts < 3) {
+          throw Object.assign(new Error("Network Error"), {
+            code: "ECONNRESET",
+            config,
+          });
+        }
+
+        return {
+          data: { success: true },
+          status: 200,
+          statusText: "OK",
+          headers: {},
+          config,
+        };
+      };
+
+      try {
+        await client.log({ event: "network.retry", value: 1 });
+        const flushPromise = client.flush();
+        await jest.runAllTimersAsync();
+        await expect(flushPromise).resolves.toBeUndefined();
+        expect(attempts).toBe(3);
+      } finally {
+        await client.shutdown();
+      }
+    });
+
+    test("retries 429 responses", async () => {
+      jest.useFakeTimers();
+      const mock = new MockAdapter(axios);
+      mock.onPost(DEFAULT_API_ENDPOINT).replyOnce(429, { error: "rate limited" }, { "retry-after": "1" });
+      mock.onPost(DEFAULT_API_ENDPOINT).replyOnce(429, { error: "rate limited" }, { "retry-after": "1" });
+      mock.onPost(DEFAULT_API_ENDPOINT).replyOnce(200, { success: true });
+
+      const client: Client = createClient({
+        key: "chp_rate_limit_key",
+        retries: 2,
+        flushDelay: 10000,
+      });
+
+      try {
+        await client.log({ event: "rate.limit", value: 1 });
+        const flushPromise = client.flush();
+        await jest.runAllTimersAsync();
+        await expect(flushPromise).resolves.toBeUndefined();
+        expect(mock.history.post.length).toBe(3);
+      } finally {
+        await client.shutdown();
+      }
+    });
+
+    test("does not retry 401 and logs the Chirpier response message", async () => {
+      const mock = new MockAdapter(axios);
+      const errorSpy = jest.spyOn(console, "error").mockImplementation(() => undefined);
+      mock.onPost(DEFAULT_API_ENDPOINT).replyOnce(401, { error: "invalid api key" });
+
+      const client: Client = createClient({
+        key: "chp_unauthorized_key",
+        retries: 3,
+        flushDelay: 10000,
+        logLevel: LogLevel.Error,
+      });
+
+      try {
+        await client.log({ event: "auth.failed", value: 1 });
+        await client.flush();
+        await client.flush();
+
+        expect(mock.history.post.length).toBe(1);
+        expect(errorSpy).toHaveBeenCalledWith("Chirpier API returned 401: invalid api key");
+      } finally {
+        await client.shutdown();
+      }
+    });
+
+    test("does not retry 403 and logs the Chirpier response message", async () => {
+      const mock = new MockAdapter(axios);
+      const errorSpy = jest.spyOn(console, "error").mockImplementation(() => undefined);
+      mock.onPost(DEFAULT_API_ENDPOINT).replyOnce(403, { message: "project is disabled" });
+
+      const client: Client = createClient({
+        key: "chp_forbidden_key",
+        retries: 3,
+        flushDelay: 10000,
+        logLevel: LogLevel.Error,
+      });
+
+      try {
+        await client.log({ event: "auth.forbidden", value: 1 });
+        await client.flush();
+        await client.flush();
+
+        expect(mock.history.post.length).toBe(1);
+        expect(errorSpy).toHaveBeenCalledWith("Chirpier API returned 403: project is disabled");
+      } finally {
+        await client.shutdown();
+      }
+    });
+
+    test.each([404, 500, 503])( "does not retry non-retryable status %s", async (status) => {
+      const mock = new MockAdapter(axios);
+      mock.onPost(DEFAULT_API_ENDPOINT).replyOnce(status, { error: `http ${status}` });
+
+      const client: Client = createClient({
+        key: `chp_non_retryable_${status}`,
+        retries: 3,
+        flushDelay: 10000,
+      });
+
+      try {
+        await client.log({ event: `non.retryable.${status}`, value: 1 });
+        await client.flush();
+        await client.flush();
+
+        expect(mock.history.post.length).toBe(1);
+      } finally {
+        await client.shutdown();
+      }
+    });
+
+    test("retries 502 responses", async () => {
+      jest.useFakeTimers();
+      const mock = new MockAdapter(axios);
+      mock.onPost(DEFAULT_API_ENDPOINT).replyOnce(502, { error: "bad gateway" });
+      mock.onPost(DEFAULT_API_ENDPOINT).replyOnce(502, { error: "bad gateway" });
+      mock.onPost(DEFAULT_API_ENDPOINT).replyOnce(200, { success: true });
+
+      const client: Client = createClient({
+        key: "chp_bad_gateway_key",
+        retries: 2,
+        flushDelay: 10000,
+      });
+
+      try {
+        await client.log({ event: "bad.gateway", value: 1 });
+        const flushPromise = client.flush();
+        await jest.runAllTimersAsync();
+        await expect(flushPromise).resolves.toBeUndefined();
+        expect(mock.history.post.length).toBe(3);
+      } finally {
+        await client.shutdown();
+      }
+    });
+
+    test("flush requeues only retryable failures", async () => {
+      const retryableMock = new MockAdapter(axios);
+      retryableMock.onPost(DEFAULT_API_ENDPOINT).replyOnce(502, { error: "bad gateway" });
+      retryableMock.onPost(DEFAULT_API_ENDPOINT).replyOnce(200, { success: true });
+
+      const retryableClient: Client = createClient({
+        key: "chp_retryable_requeue_key",
+        retries: 0,
+        flushDelay: 10000,
+      });
+
+      try {
+        await retryableClient.log({ event: "retryable.requeue", value: 1 });
+        await retryableClient.flush();
+        await retryableClient.flush();
+        expect(retryableMock.history.post.length).toBe(2);
+      } finally {
+        await retryableClient.shutdown();
+      }
+
+      const nonRetryableMock = new MockAdapter(axios);
+      nonRetryableMock.onPost(DEFAULT_API_ENDPOINT).replyOnce(404, { error: "not found" });
+
+      const nonRetryableClient: Client = createClient({
+        key: "chp_non_retryable_requeue_key",
+        retries: 0,
+        flushDelay: 10000,
+        logLevel: LogLevel.None,
+      });
+
+      try {
+        await nonRetryableClient.log({ event: "non.retryable.drop", value: 1 });
+        await nonRetryableClient.flush();
+        await nonRetryableClient.flush();
+        expect(nonRetryableMock.history.post.length).toBe(1);
+      } finally {
+        await nonRetryableClient.shutdown();
+      }
+    });
+
     test("getEventLogs uses servicer endpoint with period, limit, and offset", async () => {
       const mock = new MockAdapter(axios);
       mock.onGet("https://api.chirpier.co/v1.0/events/evt_123/logs?period=hour&limit=25&offset=10").reply(200, []);
@@ -354,6 +553,39 @@ describe("Chirpier SDK", () => {
       }
     });
 
+	  test("event, policy, alert, and destination helpers use servicer endpoints", async () => {
+		const mock = new MockAdapter(axios);
+		mock.onPost("https://api.chirpier.co/v1.0/events").reply(200, { event_id: "evt_123", event: "tool.errors.count", public: false, timezone: "UTC" });
+		mock.onGet("https://api.chirpier.co/v1.0/events/evt_123").reply(200, { event_id: "evt_123", event: "tool.errors.count", public: false, timezone: "UTC" });
+		mock.onGet("https://api.chirpier.co/v1.0/policies/pol_123").reply(200, { policy_id: "pol_123", event_id: "evt_123", title: "Policy", channel: "ops", period: "hour", aggregate: "sum", condition: "gt", threshold: 1, severity: "warning", enabled: true });
+		mock.onPut("https://api.chirpier.co/v1.0/policies/pol_123").reply(200, { policy_id: "pol_123", event_id: "evt_123", title: "Updated", channel: "ops", period: "hour", aggregate: "sum", condition: "gt", threshold: 1, severity: "warning", enabled: true });
+		mock.onGet("https://api.chirpier.co/v1.0/alerts/alrt_123").reply(200, { alert_id: "alrt_123", policy_id: "pol_123", event_id: "evt_123", event: "tool.errors.count", title: "Alert", channel: "ops", period: "hour", aggregate: "sum", condition: "gt", threshold: 1, severity: "warning", status: "triggered", value: 2, count: 2, min: 1, max: 1 });
+		mock.onGet("https://api.chirpier.co/v1.0/destinations").reply(200, []);
+		mock.onPost("https://api.chirpier.co/v1.0/destinations").reply(200, { destination_id: "dst_123", channel: "slack", scope: "all", enabled: true });
+		mock.onGet("https://api.chirpier.co/v1.0/destinations/dst_123").reply(200, { destination_id: "dst_123", channel: "slack", scope: "all", enabled: true });
+		mock.onPut("https://api.chirpier.co/v1.0/destinations/dst_123").reply(200, { destination_id: "dst_123", channel: "slack", scope: "all", enabled: false });
+
+		const client: Client = createClient({ key: "chp_client_route_key" });
+		try {
+		  const createdEvent = await client.createEvent({ event: "tool.errors.count" });
+		  expect(createdEvent.event_id).toBe("evt_123");
+		  await client.getEvent("evt_123");
+		  const policy = await client.getPolicy("pol_123");
+		  expect(policy.policy_id).toBe("pol_123");
+		  await client.updatePolicy("pol_123", { title: "Updated" });
+		  const alert = await client.getAlert("alrt_123");
+		  expect(alert.alert_id).toBe("alrt_123");
+		  await client.listDestinations();
+		  const destination = await client.createDestination({ channel: "slack", scope: "all", enabled: true });
+		  expect(destination.destination_id).toBe("dst_123");
+		  await client.getDestination("dst_123");
+		  const updatedDestination = await client.updateDestination("dst_123", { enabled: false });
+		  expect(updatedDestination.enabled).toBe(false);
+		} finally {
+		  await client.shutdown();
+		}
+	  });
+
     test("getAlertDeliveries uses pagination params", async () => {
       const mock = new MockAdapter(axios);
       mock.onGet("https://api.chirpier.co/v1.0/alerts/alrt_123/deliveries?kind=test&limit=20&offset=5").reply(200, []);
@@ -380,17 +612,46 @@ describe("Chirpier SDK", () => {
       }
     });
 
-    test("testWebhook posts to servicer endpoint", async () => {
+    test("testDestination posts to servicer endpoint", async () => {
       const mock = new MockAdapter(axios);
-      mock.onPost("https://api.chirpier.co/v1.0/webhooks/whk_123/test").reply(200);
+	  mock.onPost("https://api.chirpier.co/v1.0/destinations/whk_123/test").reply(200, {
+		alert_id: "alrt_123",
+		destination_id: "whk_123",
+		status: "sent",
+	  });
 
-      const client: Client = createClient({ key: "chp_client_webhook_key" });
+      const client: Client = createClient({ key: "chp_client_destination_key" });
       try {
-        await client.testWebhook("whk_123");
-        expect(mock.history.post[0].url).toBe("https://api.chirpier.co/v1.0/webhooks/whk_123/test");
+		const result = await client.testDestination("whk_123");
+		expect(result.alert_id).toBe("alrt_123");
+        expect(mock.history.post[0].url).toBe("https://api.chirpier.co/v1.0/destinations/whk_123/test");
       } finally {
         await client.shutdown();
       }
     });
+
+	  test("getEventAnalytics uses analytics endpoint", async () => {
+		const mock = new MockAdapter(axios);
+		mock.onGet("https://api.chirpier.co/v1.0/events/evt_123/analytics?view=window&period=1h&previous=previous_window").reply(200, {
+		  event_id: "evt_123",
+		  view: "window",
+		  period: "1h",
+		  previous: "previous_window",
+		  data: null,
+		});
+
+		const client: Client = createClient({ key: "chp_client_analytics_key" });
+		try {
+		  const analytics = await client.getEventAnalytics("evt_123", {
+			view: "window",
+			period: "1h",
+			previous: "previous_window",
+		  });
+		  expect(analytics.event_id).toBe("evt_123");
+		  expect(mock.history.get[0].url).toBe("https://api.chirpier.co/v1.0/events/evt_123/analytics?view=window&period=1h&previous=previous_window");
+		} finally {
+		  await client.shutdown();
+		}
+	  });
   });
 });

package/src/index.ts

@@ -29,7 +29,6 @@ export interface Config {
   timeout?: number;
   batchSize?: number;
   flushDelay?: number;
-  /** @deprecated Queues are unbounded in memory. */
   maxQueueSize?: number;
 }
 
@@ -59,6 +58,16 @@ export interface Event {
 	readonly created_at?: string;
 }
 
+export interface CreateEventPayload {
+	agent?: string;
+	event: string;
+	title?: string;
+	public?: boolean;
+	description?: string;
+	unit?: string;
+	timezone?: string;
+}
+
 export interface Policy {
 	readonly policy_id: string;
 	readonly event_id: string;
@@ -73,6 +82,10 @@ export interface Policy {
 	readonly enabled: boolean;
 }
 
+export type CreatePolicyPayload = Omit<Policy, "policy_id">;
+
+export type UpdatePolicyPayload = Partial<Omit<Policy, "policy_id">>;
+
 export interface Alert {
 	readonly alert_id: string;
 	readonly policy_id: string;
@@ -98,7 +111,7 @@ export interface Alert {
 export interface AlertDelivery {
 	readonly attempt_id: string;
 	readonly alert_id: string;
-	readonly webhook_id?: string;
+	readonly destination_id?: string;
 	readonly channel: string;
 	readonly target: string;
 	readonly status: string;
@@ -107,6 +120,20 @@ export interface AlertDelivery {
 	readonly created_at: string;
 }
 
+export interface Destination {
+	readonly destination_id: string;
+	readonly channel: string;
+	readonly url?: string;
+	readonly credentials?: Record<string, unknown>;
+	readonly scope: string;
+	readonly policy_ids?: string[];
+	readonly enabled: boolean;
+}
+
+export type CreateDestinationPayload = Omit<Destination, "destination_id">;
+
+export type UpdateDestinationPayload = Partial<Omit<Destination, "destination_id">>;
+
 export interface EventLogPoint {
 	readonly event_id: string;
 	readonly agent?: string;
@@ -120,6 +147,43 @@ export interface EventLogPoint {
 	readonly max: number;
 }
 
+export interface AnalyticsWindowQuery {
+	view: "window";
+	period: "1h" | "1d" | "7d" | "1m";
+	previous: "previous_window" | "previous_1d" | "previous_7d" | "previous_1m";
+}
+
+export interface AnalyticsWindowData {
+	readonly current_value: number;
+	readonly current_count: number;
+	readonly previous_value: number;
+	readonly previous_count: number;
+	readonly value_delta: number;
+	readonly count_delta: number;
+	readonly value_pct_change: number;
+	readonly count_pct_change: number;
+	readonly current_mean: number;
+	readonly previous_mean: number;
+	readonly mean_delta: number;
+	readonly mean_pct_change: number;
+	readonly current_stddev: number;
+	readonly previous_stddev: number;
+}
+
+export interface AnalyticsWindowResponse {
+	readonly event_id: string;
+	readonly view: "window";
+	readonly period: "1h" | "1d" | "7d" | "1m";
+	readonly previous: "previous_window" | "previous_1d" | "previous_7d" | "previous_1m";
+	readonly data: AnalyticsWindowData | null;
+}
+
+export interface DestinationTestResult {
+	readonly alert_id: string;
+	readonly destination_id: string;
+	readonly status: string;
+}
+
 export interface PaginationOptions {
 	period?: "minute" | "hour" | "day";
 	limit?: number;
@@ -140,6 +204,99 @@ export class ChirpierError extends Error {
   }
 }
 
+type LogRetryPolicy = "success" | "retryable" | "retry_after" | "non_retryable";
+
+function classifyLogResponseStatus(status?: number): LogRetryPolicy {
+  if (status === undefined) {
+    return "success";
+  }
+
+  if (status === 429) {
+    return "retry_after";
+  }
+
+  if (status >= 500) {
+    if (status === 500 || status === 503) {
+      return "non_retryable";
+    }
+
+    return "retryable";
+  }
+
+  if (status >= 400) {
+    return "non_retryable";
+  }
+
+  return "success";
+}
+
+function getChirpierResponseMessage(data: unknown): string | undefined {
+  if (typeof data === "string") {
+    const trimmed = data.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+  }
+
+  if (data && typeof data === "object") {
+    const record = data as Record<string, unknown>;
+    if (typeof record.message === "string" && record.message.trim().length > 0) {
+      return record.message.trim();
+    }
+
+    if (typeof record.error === "string" && record.error.trim().length > 0) {
+      return record.error.trim();
+    }
+
+    try {
+      return JSON.stringify(data);
+    } catch {
+      return undefined;
+    }
+  }
+
+  return undefined;
+}
+
+function getRetryDelayMs(retryCount: number, error: unknown): number {
+  if (axios.isAxiosError(error) && error.response?.status === 429) {
+    const retryAfterHeader = error.response.headers?.["retry-after"];
+    const retryAfterSeconds = Number(retryAfterHeader);
+    if (Number.isFinite(retryAfterSeconds) && retryAfterSeconds >= 0) {
+      return retryAfterSeconds * 1000;
+    }
+  }
+
+  const baseDelay = Math.pow(2, retryCount) * 1000;
+  const jitter = Math.random() * 0.3 * baseDelay;
+  return baseDelay + jitter;
+}
+
+function normalizeSendLogsError(error: unknown, logLevel: LogLevel): unknown {
+  if (!axios.isAxiosError(error)) {
+    return error;
+  }
+
+  const status = error.response?.status;
+  if (classifyLogResponseStatus(status) !== "non_retryable") {
+    return error;
+  }
+
+  const responseMessage = getChirpierResponseMessage(error.response?.data);
+  if ((status === 401 || status === 403) && logLevel >= LogLevel.Error) {
+    if (responseMessage) {
+      console.error(`Chirpier API returned ${status}: ${responseMessage}`);
+    } else {
+      console.error(`Chirpier API returned ${status}`);
+    }
+  }
+
+  const message = responseMessage ? `HTTP ${status}: ${responseMessage}` : `HTTP ${status}`;
+  return new ChirpierError(message, "NON_RETRYABLE_RESPONSE");
+}
+
+function isNonRetryableLogError(error: unknown): error is ChirpierError {
+  return error instanceof ChirpierError && error.code === "NON_RETRYABLE_RESPONSE";
+}
+
 interface QueuedLog {
   readonly log: Log;
   readonly timestamp: number;
@@ -247,17 +404,15 @@ export class Client {
 
     axiosRetry(this.axiosInstance, {
       retries: this.retries,
-      retryDelay: (retryCount) => {
-        const baseDelay = Math.pow(2, retryCount) * 1000;
-        const jitter = Math.random() * 0.3 * baseDelay;
-        return baseDelay + jitter;
-      },
+      retryDelay: (retryCount, error) => getRetryDelayMs(retryCount, error),
       retryCondition: (error) => {
-        return (
-          axiosRetry.isNetworkError(error) ||
-          axiosRetry.isRetryableError(error) ||
-          (error.response && error.response.status) === 429
-        );
+        if (axiosRetry.isNetworkError(error)) {
+          return true;
+        }
+
+        const status = error.response?.status;
+        const retryPolicy = classifyLogResponseStatus(status);
+        return retryPolicy === "retryable" || retryPolicy === "retry_after";
       },
       shouldResetTimeout: true,
     });
@@ -402,6 +557,13 @@ export class Client {
           console.error("Failed to send logs:", error);
         }
 
+        if (isNonRetryableLogError(error)) {
+          if (this.logLevel >= LogLevel.Error) {
+            console.error("Dropping logs after non-retryable response from API");
+          }
+          return;
+        }
+
         await this.queueLock.acquire("logQueue", async () => {
           this.logQueue = [...logsToSend, ...this.logQueue];
         });
@@ -410,7 +572,11 @@ export class Client {
   }
 
   private async sendLogs(logs: Log[]): Promise<void> {
-    await this.axiosInstance.post(this.apiEndpoint, logs);
+    try {
+      await this.axiosInstance.post(this.apiEndpoint, logs);
+    } catch (error) {
+      throw normalizeSendLogsError(error, this.logLevel);
+    }
   }
 
   public async flush(): Promise<void> {
@@ -435,6 +601,11 @@ export class Client {
 	return response.data;
   }
 
+  public async createEvent(payload: CreateEventPayload): Promise<Event> {
+	const response = await this.axiosInstance.post<Event>(`${this.servicerEndpoint}/events`, payload);
+	return response.data;
+  }
+
   public async getEvent(eventID: string): Promise<Event> {
 	const response = await this.axiosInstance.get<Event>(`${this.servicerEndpoint}/events/${eventID}`);
 	return response.data;
@@ -456,11 +627,21 @@ export class Client {
 	return response.data;
   }
 
-  public async createPolicy(payload: Omit<Policy, "policy_id">): Promise<Policy> {
+  public async getPolicy(policyID: string): Promise<Policy> {
+	const response = await this.axiosInstance.get<Policy>(`${this.servicerEndpoint}/policies/${policyID}`);
+	return response.data;
+  }
+
+  public async createPolicy(payload: CreatePolicyPayload): Promise<Policy> {
 	const response = await this.axiosInstance.post<Policy>(`${this.servicerEndpoint}/policies`, payload);
 	return response.data;
   }
 
+  public async updatePolicy(policyID: string, payload: UpdatePolicyPayload): Promise<Policy> {
+	const response = await this.axiosInstance.put<Policy>(`${this.servicerEndpoint}/policies/${policyID}`, payload);
+	return response.data;
+  }
+
   public async listAlerts(status?: string): Promise<Alert[]> {
 	const endpoint = status
 		? `${this.servicerEndpoint}/alerts?status=${encodeURIComponent(status)}`
@@ -469,6 +650,11 @@ export class Client {
 	return response.data;
   }
 
+  public async getAlert(alertID: string): Promise<Alert> {
+	const response = await this.axiosInstance.get<Alert>(`${this.servicerEndpoint}/alerts/${alertID}`);
+	return response.data;
+  }
+
   public async getAlertDeliveries(alertID: string, options: { limit?: number; offset?: number; kind?: DeliveryKind } = {}): Promise<AlertDelivery[]> {
 	const params = new URLSearchParams();
 	if (options.kind) {
@@ -495,8 +681,29 @@ export class Client {
 	return response.data;
   }
 
-  public async testWebhook(webhookID: string): Promise<void> {
-	await this.axiosInstance.post(`${this.servicerEndpoint}/webhooks/${webhookID}/test`);
+  public async listDestinations(): Promise<Destination[]> {
+	const response = await this.axiosInstance.get<Destination[]>(`${this.servicerEndpoint}/destinations`);
+	return response.data;
+  }
+
+  public async createDestination(payload: CreateDestinationPayload): Promise<Destination> {
+	const response = await this.axiosInstance.post<Destination>(`${this.servicerEndpoint}/destinations`, payload);
+	return response.data;
+  }
+
+  public async getDestination(destinationID: string): Promise<Destination> {
+	const response = await this.axiosInstance.get<Destination>(`${this.servicerEndpoint}/destinations/${destinationID}`);
+	return response.data;
+  }
+
+  public async updateDestination(destinationID: string, payload: UpdateDestinationPayload): Promise<Destination> {
+	const response = await this.axiosInstance.put<Destination>(`${this.servicerEndpoint}/destinations/${destinationID}`, payload);
+	return response.data;
+  }
+
+  public async testDestination(destinationID: string): Promise<DestinationTestResult> {
+	const response = await this.axiosInstance.post<DestinationTestResult>(`${this.servicerEndpoint}/destinations/${destinationID}/test`);
+	return response.data;
   }
 
   public async getEventLogs(eventID: string, options: PaginationOptions = {}): Promise<EventLogPoint[]> {
@@ -515,6 +722,15 @@ export class Client {
 	return response.data;
   }
 
+  public async getEventAnalytics(eventID: string, query: AnalyticsWindowQuery): Promise<AnalyticsWindowResponse> {
+	const params = new URLSearchParams();
+	params.set("view", query.view);
+	params.set("period", query.period);
+	params.set("previous", query.previous);
+	const response = await this.axiosInstance.get<AnalyticsWindowResponse>(`${this.servicerEndpoint}/events/${eventID}/analytics?${params.toString()}`);
+	return response.data;
+  }
+
   public async resolveAlert(alertID: string): Promise<Alert> {
 	const response = await this.axiosInstance.post<Alert>(`${this.servicerEndpoint}/alerts/${alertID}/resolve`);
 	return response.data;