@rustrak/client 0.3.5 → 0.3.7

package/dist/index.cjs

@@ -608,6 +608,42 @@ var sourceMapFileSchema = zod.z.object({
 var listSourceMapsResponseSchema = zod.z.object({
   data: zod.z.array(sourceMapFileSchema)
 });
+var sourceMapStorageSchema = zod.z.object({
+  chunk_bytes: zod.z.number(),
+  source_file_bytes: zod.z.number(),
+  total_bytes: zod.z.number(),
+  file_count: zod.z.number()
+});
+var storageSummarySchema = zod.z.object({
+  total_db_size_bytes: zod.z.number(),
+  events_count: zod.z.number(),
+  transactions_count: zod.z.number(),
+  spans_count: zod.z.number(),
+  source_maps: sourceMapStorageSchema
+});
+var projectStorageSchema = zod.z.object({
+  project_id: zod.z.number(),
+  project_name: zod.z.string(),
+  events_count: zod.z.number(),
+  transactions_count: zod.z.number(),
+  spans_count: zod.z.number(),
+  source_maps_count: zod.z.number(),
+  estimated_bytes: zod.z.number()
+});
+var cleanupCountsSchema = zod.z.object({
+  events: zod.z.number(),
+  transactions: zod.z.number(),
+  spans: zod.z.number(),
+  issues_removed: zod.z.number()
+});
+var sourceMapGcResultSchema = zod.z.object({
+  files_removed: zod.z.number(),
+  bytes_freed: zod.z.number()
+});
+var cleanupOptionsSchema = zod.z.object({
+  older_than_days: zod.z.number().int().min(1),
+  project_id: zod.z.number().int().optional()
+});
 var authTokenSchema = zod.z.object({
   id: zod.z.number().int(),
   token_prefix: zod.z.string(),
@@ -650,6 +686,30 @@ var transactionDetailSchema = zod.z.object({
   data: zod.z.record(zod.z.string(), zod.z.any())
   // Full Sentry transaction payload
 });
+var spanSchema = zod.z.object({
+  id: uuidSchema,
+  span_id: zod.z.string().nullable(),
+  trace_id: zod.z.string().nullable(),
+  parent_span_id: zod.z.string().nullable(),
+  op: zod.z.string().nullable(),
+  description: zod.z.string().nullable(),
+  status: zod.z.string().nullable(),
+  start_timestamp: dateTimeSchema.nullable(),
+  timestamp: dateTimeSchema.nullable(),
+  duration_ms: zod.z.number().nullable(),
+  exclusive_time_ms: zod.z.number().nullable(),
+  is_segment: zod.z.boolean(),
+  segment_id: zod.z.string().nullable()
+});
+var transactionStatsSchema = zod.z.object({
+  transaction_name: zod.z.string(),
+  op: zod.z.string().nullable(),
+  count: zod.z.number().int(),
+  p50_ms: zod.z.number(),
+  p95_ms: zod.z.number(),
+  p99_ms: zod.z.number(),
+  failure_rate: zod.z.number()
+});
 
 // src/resources/events.ts
 var EventsResource = class extends BaseResource {
@@ -917,6 +977,59 @@ var SourceMapsResource = class extends BaseResource {
     return this.validate(data, listSourceMapsResponseSchema);
   }
 };
+var StorageResource = class extends BaseResource {
+  /**
+   * Get the instance-wide storage summary: row counts per data category, the
+   * whole-DB size, and exact source-map weight.
+   */
+  async getSummary() {
+    const data = await this.http.get("api/storage/summary").json();
+    return this.validate(data, storageSummarySchema);
+  }
+  /**
+   * Get the per-project storage breakdown (one row per project, including
+   * empty ones).
+   */
+  async getProjects() {
+    const data = await this.http.get("api/storage/projects").json();
+    return this.validate(data, zod.z.array(projectStorageSchema));
+  }
+  /**
+   * Dry-run: count the rows a cleanup would remove. Mutates nothing — use it to
+   * confirm impact before {@link executeCleanup}.
+   */
+  async previewCleanup(options) {
+    const json = cleanupOptionsSchema.parse(options);
+    const data = await this.http.post("api/storage/cleanup/preview", { json }).json();
+    return this.validate(data, cleanupCountsSchema);
+  }
+  /**
+   * Execute a cleanup: delete data older than `older_than_days` (optionally
+   * scoped to one project) and remove any issue left with zero events.
+   */
+  async executeCleanup(options) {
+    const json = cleanupOptionsSchema.parse(options);
+    const data = await this.http.post("api/storage/cleanup", { json }).json();
+    return this.validate(data, cleanupCountsSchema);
+  }
+  /**
+   * Dry-run for {@link gcSourceMaps}: count the orphaned source-map files and
+   * bytes a GC would reclaim. Mutates nothing.
+   */
+  async previewGcSourceMaps() {
+    const data = await this.http.post("api/storage/source-maps/gc/preview").json();
+    return this.validate(data, sourceMapGcResultSchema);
+  }
+  /**
+   * Garbage-collect orphaned source maps: files no longer referenced by any
+   * upload, removed from the DB and unlinked from disk. Safe — never touches
+   * referenced files.
+   */
+  async gcSourceMaps() {
+    const data = await this.http.post("api/storage/source-maps/gc").json();
+    return this.validate(data, sourceMapGcResultSchema);
+  }
+};
 
 // src/resources/team.ts
 var TeamResource = class extends BaseResource {
@@ -977,8 +1090,6 @@ var TokensResource = class extends BaseResource {
     await this.http.delete(`api/tokens/${id}`);
   }
 };
-
-// src/resources/transactions.ts
 var TransactionsResource = class extends BaseResource {
   /**
    * List transactions for a project with offset-based pagination (newest first)
@@ -991,6 +1102,21 @@ var TransactionsResource = class extends BaseResource {
     if (options?.per_page) {
       searchParams.per_page = String(options.per_page);
     }
+    if (options?.name) {
+      searchParams.name = options.name;
+    }
+    if (options?.op) {
+      searchParams.op = options.op;
+    }
+    if (options?.status) {
+      searchParams.status = options.status;
+    }
+    if (options?.environment) {
+      searchParams.environment = options.environment;
+    }
+    if (options?.release) {
+      searchParams.release = options.release;
+    }
     const data = await this.http.get(`api/projects/${projectId}/transactions`, {
       searchParams
     }).json();
@@ -999,6 +1125,47 @@ var TransactionsResource = class extends BaseResource {
       offsetPaginatedResponseSchema(transactionSchema)
     );
   }
+  /**
+   * Get the indexed spans extracted from a transaction, in waterfall order.
+   */
+  async getSpans(projectId, transactionId) {
+    const data = await this.http.get(`api/projects/${projectId}/transactions/${transactionId}/spans`).json();
+    return this.validate(data, zod.z.array(spanSchema));
+  }
+  /**
+   * Get aggregate performance stats (count, p50/p95/p99 latency, failure rate)
+   * grouped by transaction name + op, most frequent first, with offset-based
+   * pagination — same shape as the other list endpoints.
+   */
+  async getStats(projectId, options) {
+    const searchParams = {};
+    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}/transactions/stats`, { searchParams }).json();
+    return this.validate(
+      data,
+      offsetPaginatedResponseSchema(transactionStatsSchema)
+    );
+  }
+  /**
+   * Get aggregate stats for a single (transaction name, op) group — a direct
+   * lookup that works regardless of how many groups the project has. Throws
+   * NotFoundError when the group has no transactions.
+   */
+  async getStatForGroup(projectId, name, op) {
+    const searchParams = { name };
+    if (op) {
+      searchParams.op = op;
+    }
+    const data = await this.http.get(`api/projects/${projectId}/transactions/stats/group`, {
+      searchParams
+    }).json();
+    return this.validate(data, transactionStatsSchema);
+  }
   /**
    * Get a single transaction by ID with its full Sentry payload (spans,
    * contexts.trace, measurements, tags) for the performance detail view.
@@ -1127,6 +1294,10 @@ var RustrakClient = class {
    * Transactions API resource (performance monitoring)
    */
   transactions;
+  /**
+   * Storage API resource (usage + retention cleanup, admin only)
+   */
+  storage;
   /**
    * Health API resource (version info)
    */
@@ -1151,6 +1322,7 @@ var RustrakClient = class {
     this.members = new MembersResource(this.http);
     this.sessions = new SessionsResource(this.http);
     this.transactions = new TransactionsResource(this.http);
+    this.storage = new StorageResource(this.http);
     this.health = new HealthResource(this.http);
   }
 };