@rustrak/client 0.12.1 → 0.12.3

package/dist/index.cjs

@@ -394,7 +394,6 @@ var releaseHealthRowSchema = zod.z.object({
   crash_free_sessions_rate: zod.z.number().nullable(),
   crash_free_users_rate: zod.z.number().nullable()
 });
-var releaseHealthSchema = zod.z.array(releaseHealthRowSchema);
 var sessionSummarySchema = zod.z.object({
   total: zod.z.number().int(),
   errored: zod.z.number().int(),
@@ -435,6 +434,27 @@ var sourceMapFileSchema = zod.z.object({
 var listSourceMapsResponseSchema = zod.z.object({
   data: zod.z.array(sourceMapFileSchema)
 });
+var eventTimeseriesPointSchema = zod.z.object({
+  bucket: dateTimeSchema,
+  total: zod.z.number().int(),
+  fatal: zod.z.number().int(),
+  error: zod.z.number().int(),
+  warning: zod.z.number().int(),
+  info: zod.z.number().int()
+});
+var eventTimeseriesSchema = zod.z.array(eventTimeseriesPointSchema);
+var metricDeltaSchema = zod.z.object({
+  current: zod.z.number().int(),
+  previous: zod.z.number().int().nullable()
+});
+var projectStatsSummarySchema = zod.z.object({
+  /** Resolved window in hours, or `null` for all time. */
+  period_hours: zod.z.number().int().nullable(),
+  events: metricDeltaSchema,
+  new_issues: metricDeltaSchema,
+  /** Currently unresolved issues, independent of the window. */
+  open_issues: zod.z.number().int()
+});
 var sourceMapStorageSchema = zod.z.object({
   chunk_bytes: zod.z.number(),
   source_file_bytes: zod.z.number(),
@@ -1339,22 +1359,30 @@ var ReleasesResource = class extends BaseResource {
 // src/resources/sessions.ts
 var SessionsResource = class extends BaseResource {
   /**
-   * Get per-release health stats for a project.
+   * Get per-release health stats for a project, one offset-based page of
+   * (release, environment) rows at a time, ordered by session volume.
    * @param projectId - Project ID
-   * @param period - Time window (e.g. '24h', '7d'). Defaults to '24h'.
-   * @param release - Scope to a single release (all environments), computed
-   *   server-side. Omit to get every release in the project.
+   * @param options - Time window, release scoping and pagination.
    */
-  async stats(projectId, period, release) {
+  async stats(projectId, options) {
     const searchParams = {};
-    if (period) {
-      searchParams.period = period;
+    if (options?.period) {
+      searchParams.period = options.period;
     }
-    if (release) {
-      searchParams.release = release;
+    if (options?.release) {
+      searchParams.release = options.release;
+    }
+    if (options?.page) {
+      searchParams.page = String(options.page);
+    }
+    if (options?.per_page) {
+      searchParams.per_page = String(options.per_page);
     }
     const data = await this.http.get(`api/projects/${projectId}/sessions/stats`, { searchParams }).json();
-    return this.validate(data, releaseHealthSchema);
+    return this.validate(
+      data,
+      offsetPaginatedResponseSchema(releaseHealthRowSchema)
+    );
   }
   /**
    * Get project-wide session health, aggregated across all releases and environments.
@@ -1471,6 +1499,48 @@ var SpansResource = class extends BaseResource {
     return this.validate(data, offsetPaginatedResponseSchema(spanSchema));
   }
 };
+
+// src/resources/stats.ts
+var StatsResource = class extends BaseResource {
+  /**
+   * Get time-bucketed error-event volume for a project, split by severity.
+   *
+   * Buckets are zero-filled across the window, so a quiet hour comes back as a
+   * point with `total: 0` rather than being absent. All-time requests (no
+   * `period`) are sparse: there is no lower bound to fill from.
+   *
+   * @param projectId - Project ID
+   * @param period - Time window (e.g. '24h', '7d'). Omit for all time.
+   * @param interval - Bucket width in hours (default: 1, max: 24).
+   */
+  async timeseries(projectId, period, interval) {
+    const searchParams = {};
+    if (period) {
+      searchParams.period = period;
+    }
+    if (interval !== void 0) {
+      searchParams.interval = interval.toString();
+    }
+    const data = await this.http.get(`api/projects/${projectId}/events/stats`, { searchParams }).json();
+    return this.validate(data, eventTimeseriesSchema);
+  }
+  /**
+   * Get project-wide counters for a window, each paired with the same counter
+   * over the window immediately before it.
+   *
+   * @param projectId - Project ID
+   * @param period - Time window (e.g. '24h', '7d'). Omit for all time, which
+   *   leaves every `previous` null.
+   */
+  async summary(projectId, period) {
+    const searchParams = {};
+    if (period) {
+      searchParams.period = period;
+    }
+    const data = await this.http.get(`api/projects/${projectId}/stats/summary`, { searchParams }).json();
+    return this.validate(data, projectStatsSummarySchema);
+  }
+};
 var StorageResource = class extends BaseResource {
   /**
    * Get the instance-wide storage summary: row counts per data category, the
@@ -1807,6 +1877,10 @@ var RustrakClient = class {
    * AI Agent Monitoring dashboard API resource
    */
   agents;
+  /**
+   * Stats API resource (project-wide overview aggregates)
+   */
+  stats;
   /**
    * Storage API resource (usage + retention cleanup, admin only)
    */
@@ -1839,6 +1913,7 @@ var RustrakClient = class {
     this.logs = new LogsResource(this.http);
     this.spans = new SpansResource(this.http);
     this.agents = new AgentsResource(this.http);
+    this.stats = new StatsResource(this.http);
     this.storage = new StorageResource(this.http);
     this.health = new HealthResource(this.http);
   }