@rustrak/client 0.17.0 → 0.18.1

package/dist/index.js

@@ -502,6 +502,96 @@ var upsertProjectMemberSchema = z.object({
   user_id: z.number().int(),
   role: projectRoleSchema
 });
+var intervalUnitSchema = z.enum([
+  "minute",
+  "hour",
+  "day",
+  "week",
+  "month",
+  "year"
+]);
+var scheduleSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("crontab"), value: z.string() }),
+  z.object({
+    type: z.literal("interval"),
+    value: z.number().int().min(1),
+    unit: intervalUnitSchema
+  })
+]);
+var previewScheduleSchema = z.object({
+  schedule: scheduleSchema,
+  /** IANA zone the schedule is read in. Defaults to UTC. */
+  timezone: z.string().optional()
+});
+var schedulePreviewSchema = z.object({
+  next_runs: z.array(dateTimeSchema)
+});
+
+// src/schemas/monitor.ts
+var monitorConfigSchema = z.object({
+  schedule: scheduleSchema,
+  checkin_margin: z.number().int(),
+  max_runtime: z.number().int(),
+  timezone: z.string(),
+  failure_issue_threshold: z.number().int(),
+  recovery_threshold: z.number().int()
+});
+var monitorConfigInputSchema = z.object({
+  schedule: scheduleSchema.optional(),
+  checkin_margin: z.number().int().min(1).optional(),
+  max_runtime: z.number().int().min(1).optional(),
+  timezone: z.string().optional(),
+  failure_issue_threshold: z.number().int().min(1).max(720).optional(),
+  recovery_threshold: z.number().int().min(1).max(720).optional()
+});
+var checkInStatusSchema = z.enum([
+  "ok",
+  "error",
+  "in_progress",
+  "missed",
+  "timeout",
+  "unknown"
+]);
+var monitorEnvironmentStatusSchema = z.enum(["active", "ok", "error"]);
+var checkInSchema = z.object({
+  id: uuidSchema,
+  environment: z.string(),
+  status: checkInStatusSchema,
+  duration_ms: z.number().int().nullable(),
+  date_added: dateTimeSchema,
+  date_updated: dateTimeSchema,
+  expected_time: dateTimeSchema.nullable()
+});
+var monitorEnvironmentSchema = z.object({
+  id: uuidSchema,
+  environment: z.string(),
+  status: monitorEnvironmentStatusSchema,
+  next_checkin: dateTimeSchema.nullable(),
+  next_checkin_latest: dateTimeSchema.nullable(),
+  last_checkin: dateTimeSchema.nullable(),
+  /** Newest first. */
+  recent_checkins: z.array(checkInSchema)
+});
+var monitorSchema = z.object({
+  id: uuidSchema,
+  slug: z.string(),
+  name: z.string(),
+  config: monitorConfigSchema,
+  is_muted: z.boolean(),
+  created_at: dateTimeSchema,
+  environments: z.array(monitorEnvironmentSchema)
+});
+var createMonitorSchema = z.object({
+  name: z.string().trim().min(1).max(128),
+  /** Derived from `name` when left out. */
+  slug: z.string().min(1).max(50).optional(),
+  config: monitorConfigInputSchema
+});
+var updateMonitorSchema = z.object({
+  name: z.string().trim().min(1).max(128).optional(),
+  config: monitorConfigInputSchema.optional(),
+  is_muted: z.boolean().optional()
+});
 var metricDeltaSchema = z.object({
   current: z.number().int(),
   /**
@@ -674,14 +764,21 @@ var projectStorageSchema = z.object({
   spans_count: z.number(),
   logs_count: z.number(),
   source_maps_count: z.number(),
-  estimated_bytes: z.number()
+  /** `events_bytes + transactions_bytes + logs_bytes`. */
+  estimated_bytes: z.number(),
+  events_bytes: z.number(),
+  /** Transactions with their spans. */
+  transactions_bytes: z.number(),
+  logs_bytes: z.number()
 });
 var cleanupCountsSchema = z.object({
   events: z.number(),
   transactions: z.number(),
   spans: z.number(),
   logs: z.number(),
-  issues_removed: z.number()
+  issues_removed: z.number(),
+  /** Unused source maps deleted; only a retention cleanup removes them. */
+  source_maps: z.number().default(0)
 });
 var cleanupStatusSchema = z.object({
   state: z.enum(["idle", "running", "completed", "failed"]),
@@ -694,6 +791,53 @@ var sourceMapGcResultSchema = z.object({
   files_removed: z.number(),
   bytes_freed: z.number()
 });
+var kindAgeSchema = z.object({
+  counts: z.array(z.number()),
+  oldest: dateTimeSchema.nullable()
+});
+var storageAgeSchema = z.object({
+  bucket_days: z.array(z.number()),
+  projects: z.array(
+    z.object({
+      project_id: z.number(),
+      events: kindAgeSchema,
+      transactions: kindAgeSchema,
+      logs: kindAgeSchema
+    })
+  )
+});
+var retentionDaysSchema = z.number().int().min(1).max(36500).nullable();
+var retentionWindowsSchema = z.object({
+  events_days: retentionDaysSchema,
+  /** Transactions with their spans. */
+  transactions_days: retentionDaysSchema,
+  logs_days: retentionDaysSchema
+});
+var projectRetentionSchema = retentionWindowsSchema.extend({
+  project_id: z.number().int()
+});
+var retentionSettingsSchema = z.object({
+  defaults: retentionWindowsSchema,
+  overrides: z.array(projectRetentionSchema),
+  frequency: z.enum(["daily", "weekly"]),
+  /** Hour of the day, UTC. */
+  hour: z.number().int().min(0).max(23),
+  /** Day of a weekly cleanup, 0 = Sunday. */
+  weekday: z.number().int().min(0).max(6)
+});
+var retentionRunSchema = z.object({
+  started_at: dateTimeSchema,
+  finished_at: dateTimeSchema.nullable(),
+  status: z.enum(["running", "ok", "error"]),
+  removed: cleanupCountsSchema.nullable(),
+  error: z.string().nullable()
+});
+var retentionSchema = z.object({
+  settings: retentionSettingsSchema,
+  /** Null while everything is kept forever, and for up to a minute after the settings change. */
+  next_run_at: dateTimeSchema.nullable(),
+  last_run: retentionRunSchema.nullable()
+});
 var cleanupOptionsSchema = z.object({
   older_than_days: z.number().int().min(1),
   project_id: z.number().int().optional(),
@@ -2200,6 +2344,77 @@ var MembersResource = class extends BaseResource {
     );
   }
 };
+var MonitorsResource = class extends BaseResource {
+  /** Every monitor of a project, with its environments and recent check-ins. */
+  async list(projectId) {
+    return this.request(
+      () => this.http.get(`api/projects/${projectId}/monitors`),
+      z.array(monitorSchema)
+    );
+  }
+  async get(projectId, slug) {
+    return this.request(
+      () => this.http.get(
+        `api/projects/${projectId}/monitors/${encodeURIComponent(slug)}`
+      ),
+      monitorSchema
+    );
+  }
+  async create(projectId, input) {
+    const validated = this.validateInput(input, createMonitorSchema);
+    if (!validated.success) {
+      return validated;
+    }
+    return this.request(
+      () => this.http.post(`api/projects/${projectId}/monitors`, {
+        json: validated.data
+      }),
+      monitorSchema
+    );
+  }
+  /** Fields left out keep their value, including each field of `config`. */
+  async update(projectId, slug, input) {
+    const validated = this.validateInput(input, updateMonitorSchema);
+    if (!validated.success) {
+      return validated;
+    }
+    return this.request(
+      () => this.http.put(
+        `api/projects/${projectId}/monitors/${encodeURIComponent(slug)}`,
+        { json: validated.data }
+      ),
+      monitorSchema
+    );
+  }
+  /** Deletes the monitor and its check-ins. Its issues stay. */
+  async delete(projectId, slug) {
+    return this.requestVoid(
+      () => this.http.delete(
+        `api/projects/${projectId}/monitors/${encodeURIComponent(slug)}`
+      )
+    );
+  }
+  /** Check-ins of one monitor, newest first. */
+  async listCheckIns(projectId, slug, options) {
+    const searchParams = {};
+    if (options?.page) {
+      searchParams.page = String(options.page);
+    }
+    if (options?.per_page) {
+      searchParams.per_page = String(options.per_page);
+    }
+    if (options?.environment) {
+      searchParams.environment = options.environment;
+    }
+    return this.request(
+      () => this.http.get(
+        `api/projects/${projectId}/monitors/${encodeURIComponent(slug)}/checkins`,
+        { searchParams }
+      ),
+      offsetPaginatedResponseSchema(checkInSchema)
+    );
+  }
+};
 
 // src/resources/projects.ts
 var ProjectsResource = class extends BaseResource {
@@ -2301,6 +2516,21 @@ var ReleasesResource = class extends BaseResource {
   }
 };
 
+// src/resources/schedules.ts
+var SchedulesResource = class extends BaseResource {
+  /** Validates a schedule and lists its next five runs. */
+  async preview(input) {
+    const validated = this.validateInput(input, previewScheduleSchema);
+    if (!validated.success) {
+      return validated;
+    }
+    return this.request(
+      () => this.http.post("api/schedules/preview", { json: validated.data }),
+      schedulePreviewSchema
+    );
+  }
+};
+
 // src/resources/sessions.ts
 var SessionsResource = class extends BaseResource {
   /**
@@ -2633,6 +2863,66 @@ var StorageResource = class extends BaseResource {
       sourceMapGcResultSchema
     );
   }
+  /**
+   * Retention: how long each kind of data is kept, by default and per
+   * project, when its cleanup runs next and how the last one went.
+   */
+  async getRetention() {
+    return this.request(
+      () => this.http.get("api/storage/retention"),
+      retentionSchema
+    );
+  }
+  /** Replaces the retention settings. A new schedule applies within a minute. */
+  async updateRetention(settings) {
+    const validated = this.validateInput(settings, retentionSettingsSchema);
+    if (!validated.success) {
+      return validated;
+    }
+    return this.request(
+      () => this.http.put("api/storage/retention", { json: validated.data }),
+      retentionSchema
+    );
+  }
+  /**
+   * Enforces the saved retention now, without waiting for the schedule, and
+   * deletes unused source maps. Returns the started job; follow it with
+   * {@link getCleanupStatus}. A `validation` error while everything is kept
+   * forever, `conflict` while a cleanup runs.
+   */
+  async runRetention() {
+    return this.request(
+      () => this.http.post("api/storage/retention/run", {
+        // No retry, as for `executeCleanup`: a lost response after the
+        // cleanup started would be retried into a refused second run.
+        retry: 0
+      }),
+      cleanupStatusSchema
+    );
+  }
+  /** How long ago each project's data arrived, per kind, in age buckets. */
+  async getAge() {
+    return this.request(
+      () => this.http.get("api/storage/age"),
+      storageAgeSchema
+    );
+  }
+  /**
+   * Dry-run: what enforcing these retention settings now would delete, each
+   * project against its own windows. Saves and deletes nothing.
+   */
+  async previewRetention(settings) {
+    const validated = this.validateInput(settings, retentionSettingsSchema);
+    if (!validated.success) {
+      return validated;
+    }
+    return this.request(
+      () => this.http.post("api/storage/retention/preview", {
+        json: validated.data
+      }),
+      cleanupCountsSchema
+    );
+  }
 };
 
 // src/resources/team.ts
@@ -2872,6 +3162,14 @@ var RustrakClient = class {
    * Logs API resource (standalone logs)
    */
   logs;
+  /**
+   * Cron monitors API resource (Sentry Crons)
+   */
+  monitors;
+  /**
+   * Schedules API resource (previews for crontab/interval schedules)
+   */
+  schedules;
   /**
    * Spans API resource (standalone + transaction-embedded spans, shared table)
    */
@@ -2919,6 +3217,8 @@ var RustrakClient = class {
     this.releases = new ReleasesResource(this.http);
     this.transactions = new TransactionsResource(this.http);
     this.logs = new LogsResource(this.http);
+    this.monitors = new MonitorsResource(this.http);
+    this.schedules = new SchedulesResource(this.http);
     this.spans = new SpansResource(this.http);
     this.agents = new AgentsResource(this.http);
     this.stats = new StatsResource(this.http);