@oneuptime/common 11.0.12 → 11.0.14

package/Models/DatabaseModels/DockerResource.ts

@@ -192,7 +192,7 @@ export default class DockerResource extends BaseModel {
   })
   @TableColumn({
     required: true,
-    type: TableColumnType.ShortText,
+    type: TableColumnType.LongText,
     canReadOnRelationQuery: true,
     title: "Name",
     description:
@@ -200,8 +200,8 @@ export default class DockerResource extends BaseModel {
   })
   @Column({
     nullable: false,
-    type: ColumnType.ShortText,
-    length: ColumnLength.ShortText,
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
   })
   public name?: string = undefined;
 
@@ -232,7 +232,7 @@ export default class DockerResource extends BaseModel {
   })
   @TableColumn({
     required: false,
-    type: TableColumnType.ShortText,
+    type: TableColumnType.LongText,
     canReadOnRelationQuery: true,
     title: "Image Name",
     description:
@@ -240,8 +240,8 @@ export default class DockerResource extends BaseModel {
   })
   @Column({
     nullable: true,
-    type: ColumnType.ShortText,
-    length: ColumnLength.ShortText,
+    type: ColumnType.LongText,
+    length: ColumnLength.LongText,
   })
   public imageName?: string = undefined;
 

package/Models/DatabaseModels/StatusPage.ts

@@ -1243,48 +1243,6 @@ export default class StatusPage extends BaseModel {
   })
   public showScheduledEventLabelsOnStatusPage?: boolean = undefined;
 
-  // This column is Deprectaed.
-  @ColumnAccessControl({
-    create: [
-      Permission.ProjectOwner,
-      Permission.ProjectAdmin,
-      Permission.ProjectMember,
-      Permission.StatusPageAdmin,
-      Permission.StatusPageMember,
-      Permission.CreateProjectStatusPage,
-    ],
-    read: [
-      Permission.ProjectOwner,
-      Permission.ProjectAdmin,
-      Permission.ProjectMember,
-      Permission.Viewer,
-      Permission.StatusPageAdmin,
-      Permission.StatusPageMember,
-      Permission.StatusPageViewer,
-      Permission.ReadProjectStatusPage,
-    ],
-    update: [
-      Permission.ProjectOwner,
-      Permission.ProjectAdmin,
-      Permission.ProjectMember,
-      Permission.StatusPageAdmin,
-      Permission.StatusPageMember,
-      Permission.EditProjectStatusPage,
-    ],
-  })
-  @TableColumn({
-    isDefaultValueColumn: true,
-    type: TableColumnType.Boolean,
-    title: "Enable Subscribers",
-    description: "Can subscribers subscribe to this Status Page?",
-    defaultValue: true,
-  })
-  @Column({
-    type: ColumnType.Boolean,
-    default: true,
-  })
-  public enableSubscribers?: boolean = undefined;
-
   @ColumnAccessControl({
     create: [
       Permission.ProjectOwner,

package/Server/Infrastructure/Postgres/SchemaMigrations/1782700000000-RemoveDeprecatedEnableSubscribersFromStatusPage.ts

@@ -0,0 +1,35 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Drops the deprecated StatusPage.enableSubscribers column.
+ *
+ * enableSubscribers was the old master "Can subscribers subscribe?" toggle,
+ * superseded by showSubscriberPageOnStatusPage + the per-channel
+ * enableEmailSubscribers / enableSmsSubscribers / enableSlackSubscribers flags.
+ * It was already marked deprecated in the model and gated nothing at runtime —
+ * its only consumer was a dashboard warning banner that wrongly claimed "no
+ * notifications will be sent" when it was off. That banner has been corrected,
+ * so this column now has no readers and is safe to remove.
+ *
+ * NOTE: the SQL below is exactly what `npm run generate-postgres-migration`
+ * produced for this model change; the generator additionally emitted unrelated
+ * cosmetic JSON-default churn on OnCallDutyPolicyScheduleLayer, which was
+ * stripped so this migration only does the intended drop.
+ */
+export class RemoveDeprecatedEnableSubscribersFromStatusPage1782700000000
+  implements MigrationInterface
+{
+  public name = "RemoveDeprecatedEnableSubscribersFromStatusPage1782700000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" DROP COLUMN "enableSubscribers"`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" ADD "enableSubscribers" boolean NOT NULL DEFAULT true`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1782800000000-WidenDockerResourceImageColumns.ts

@@ -0,0 +1,45 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class WidenDockerResourceImageColumns1782800000000
+  implements MigrationInterface
+{
+  public name = "WidenDockerResourceImageColumns1782800000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * DockerResource."name" holds the FULL image reference for Image-kind
+     * rows, and "imageName" holds the container's image reference — both can
+     * exceed varchar(100) (registry host + path + tag + @sha256 digest). An
+     * oversized value raised "value too long for type character varying(100)"
+     * (22001) and aborted the ENTIRE Docker snapshot batch INSERT, dropping
+     * every container in the flush. Widen both to varchar(500) (LongText).
+     * Increasing a varchar length cap is a metadata-only change in Postgres
+     * (no table rewrite).
+     */
+    await queryRunner.query(
+      `ALTER TABLE "DockerResource" ALTER COLUMN "name" TYPE character varying(500)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "DockerResource" ALTER COLUMN "imageName" TYPE character varying(500)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * Narrowing back to varchar(100) will fail if any stored value now
+     * exceeds 100 chars; truncate first so the down migration is safe.
+     */
+    await queryRunner.query(
+      `UPDATE "DockerResource" SET "name" = LEFT("name", 100) WHERE LENGTH("name") > 100`,
+    );
+    await queryRunner.query(
+      `UPDATE "DockerResource" SET "imageName" = LEFT("imageName", 100) WHERE "imageName" IS NOT NULL AND LENGTH("imageName") > 100`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "DockerResource" ALTER COLUMN "name" TYPE character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "DockerResource" ALTER COLUMN "imageName" TYPE character varying(100)`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -398,6 +398,8 @@ import { MigrationName1782310000000 } from "./1782310000000-MigrationName";
 import { RemoveIsTestedFromGlobalSsoAndOidc1782400000000 } from "./1782400000000-RemoveIsTestedFromGlobalSsoAndOidc";
 import { OptimizeTelemetryExceptionWritePath1782500000000 } from "./1782500000000-OptimizeTelemetryExceptionWritePath";
 import { AddArchiveToResources1782600000000 } from "./1782600000000-AddArchiveToResources";
+import { RemoveDeprecatedEnableSubscribersFromStatusPage1782700000000 } from "./1782700000000-RemoveDeprecatedEnableSubscribersFromStatusPage";
+import { WidenDockerResourceImageColumns1782800000000 } from "./1782800000000-WidenDockerResourceImageColumns";
 
 export default [
   InitialMigration,
@@ -800,4 +802,6 @@ export default [
   RemoveIsTestedFromGlobalSsoAndOidc1782400000000,
   OptimizeTelemetryExceptionWritePath1782500000000,
   AddArchiveToResources1782600000000,
+  RemoveDeprecatedEnableSubscribersFromStatusPage1782700000000,
+  WidenDockerResourceImageColumns1782800000000,
 ];

package/Server/Infrastructure/Queue.ts

@@ -440,4 +440,126 @@ export default class Queue {
       return result;
     });
   }
+
+  /**
+   * Like getFailedJobs, but returns the FULL job for deep debugging: the job
+   * body (data), its options, return value, progress, all the timing/attempt
+   * metadata, and the per-job log lines BullMQ keeps (job.log()/getJobLogs).
+   * Used by the master-admin health dashboard / support bundle. The caller is
+   * responsible for redacting / size-capping before exposing this, since the
+   * job body can contain customer data.
+   */
+  @CaptureSpan()
+  public static async getFailedJobsWithDetails(
+    queueName: QueueName,
+    options?: {
+      start?: number;
+      end?: number;
+    },
+  ): Promise<
+    Array<{
+      id: string;
+      name: string;
+      data: JSONObject;
+      opts: JSONObject;
+      returnValue: unknown;
+      progress: number | Record<string, unknown> | null;
+      failedReason: string;
+      stackTrace: Array<string>;
+      logs: Array<string>;
+      attemptsMade: number;
+      attemptsStarted: number | null;
+      stalledCounter: number | null;
+      priority: number | null;
+      delay: number | null;
+      createdAt: Date | null;
+      processedOn: Date | null;
+      finishedOn: Date | null;
+      queueQualifiedName: string | null;
+      repeatJobKey: string | null;
+      deduplicationId: string | null;
+      processedBy: string | null;
+      parentKey: string | null;
+    }>
+  > {
+    const queue: BullQueue = this.getQueue(queueName);
+    const start: number = options?.start || 0;
+    const end: number = options?.end ?? 100;
+    const failed: Job[] = await queue.getFailed(start, end);
+
+    const results: Array<{
+      id: string;
+      name: string;
+      data: JSONObject;
+      opts: JSONObject;
+      returnValue: unknown;
+      progress: number | Record<string, unknown> | null;
+      failedReason: string;
+      stackTrace: Array<string>;
+      logs: Array<string>;
+      attemptsMade: number;
+      attemptsStarted: number | null;
+      stalledCounter: number | null;
+      priority: number | null;
+      delay: number | null;
+      createdAt: Date | null;
+      processedOn: Date | null;
+      finishedOn: Date | null;
+      queueQualifiedName: string | null;
+      repeatJobKey: string | null;
+      deduplicationId: string | null;
+      processedBy: string | null;
+      parentKey: string | null;
+    }> = [];
+
+    for (const job of failed) {
+      // Per-job log lines are best-effort — older jobs may have none.
+      let logs: Array<string> = [];
+
+      try {
+        if (job.id) {
+          const jobLogs: { logs: string[]; count: number } =
+            await queue.getJobLogs(job.id, 0, -1);
+          logs = jobLogs?.logs || [];
+        }
+      } catch (err) {
+        logger.debug(`Failed to read logs for job ${job.id} on ${queueName}`);
+        logger.debug(err);
+      }
+
+      results.push({
+        id: job.id || "unknown",
+        name: job.name || "unknown",
+        data: (job.data as JSONObject) || {},
+        opts: (job.opts as unknown as JSONObject) || {},
+        returnValue: job.returnvalue ?? null,
+        progress: (job.progress as number | Record<string, unknown>) ?? null,
+        failedReason: job.failedReason || "No reason provided",
+        stackTrace: job.stacktrace || [],
+        logs: logs,
+        attemptsMade: job.attemptsMade || 0,
+        attemptsStarted:
+          typeof job.attemptsStarted === "number" ? job.attemptsStarted : null,
+        stalledCounter:
+          typeof job.stalledCounter === "number" ? job.stalledCounter : null,
+        priority: typeof job.priority === "number" ? job.priority : null,
+        delay: typeof job.delay === "number" ? job.delay : null,
+        createdAt:
+          typeof job.timestamp === "number" ? new Date(job.timestamp) : null,
+        processedOn:
+          typeof job.processedOn === "number"
+            ? new Date(job.processedOn)
+            : null,
+        finishedOn:
+          typeof job.finishedOn === "number" ? new Date(job.finishedOn) : null,
+        queueQualifiedName: job.queueQualifiedName || null,
+        repeatJobKey: job.repeatJobKey || null,
+        deduplicationId: job.deduplicationId || null,
+        processedBy: job.processedBy || null,
+        parentKey: job.parentKey || null,
+      });
+    }
+
+    return results;
+  }
 }

package/Server/Services/IncidentService.ts

@@ -518,6 +518,24 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
+    /*
+     * Normalize a blank incident severity to "not provided". A stored empty
+     * ObjectID (`{"_type":"ObjectID","value":""}`) deserializes to a truthy
+     * `new ObjectID("")`, which is NOT `=== undefined` and is a truthy object —
+     * so it slips past the template fallback below AND
+     * DatabaseService.checkRequiredFields, then serializes to "" → NULL on the
+     * not-null `incidentSeverityId` column (Postgres 23502). Treating it as
+     * undefined lets the template fallback fill it in when available, otherwise
+     * the required-field check rejects with a clean "incidentSeverityId is
+     * required" error instead of an opaque database failure.
+     */
+    if (
+      createBy.data.incidentSeverityId &&
+      !createBy.data.incidentSeverityId.toString()
+    ) {
+      delete createBy.data.incidentSeverityId;
+    }
+
     // Determine the initial incident state
     let initialIncidentStateId: ObjectID | undefined = undefined;
 
@@ -608,7 +626,7 @@ export class Service extends DatabaseService<Model> {
 
       if (incidentTemplate) {
         if (
-          createBy.data.incidentSeverityId === undefined &&
+          !createBy.data.incidentSeverityId?.toString() &&
           incidentTemplate.incidentSeverityId
         ) {
           createBy.data.incidentSeverityId =

package/Server/Types/Markdown.ts

@@ -7,6 +7,8 @@ export enum MarkdownContentType {
   Docs,
   Blog,
   Email,
+  // Compact rendering tuned for small surfaces (e.g. the blog validation modal).
+  BlogValidation,
 }
 
 export default class Markdown {
@@ -73,6 +75,7 @@ export default class Markdown {
   private static blogRenderer: Renderer | null = null;
   private static docsRenderer: Renderer | null = null;
   private static emailRenderer: Renderer | null = null;
+  private static blogValidationRenderer: Renderer | null = null;
 
   @CaptureSpan()
   public static async convertToHTML(
@@ -93,6 +96,10 @@ export default class Markdown {
       renderer = this.getEmailRenderer();
     }
 
+    if (contentType === MarkdownContentType.BlogValidation) {
+      renderer = this.getBlogValidationRenderer();
+    }
+
     /*
      * Escape raw HTML tokens in the markdown source to prevent XSS.
      * This only affects raw HTML that users type directly (e.g. <img onerror=...>),
@@ -132,6 +139,102 @@ export default class Markdown {
     return renderer;
   }
 
+  /*
+   * Compact renderer for small surfaces like the blog validation modal. Smaller,
+   * quieter headings (no oversized doc titles, no permalink anchors), tight
+   * paragraph/list rhythm, and subtle code styling so a long report stays
+   * readable in a constrained, scrollable panel.
+   */
+  private static getBlogValidationRenderer(): Renderer {
+    if (this.blogValidationRenderer !== null) {
+      return this.blogValidationRenderer;
+    }
+
+    const renderer: Renderer = new Renderer();
+
+    renderer.heading = function (text, level) {
+      if (level <= 2) {
+        return `<h3 class="mt-7 mb-3 pt-6 border-t border-gray-100 first:mt-0 first:pt-0 first:border-t-0 text-[0.7rem] font-semibold uppercase tracking-wider text-emerald-700">${text}</h3>`;
+      }
+      if (level === 3) {
+        return `<h4 class="mt-5 mb-1.5 text-sm font-semibold text-gray-900">${text}</h4>`;
+      }
+      return `<h5 class="mt-4 mb-1 text-sm font-semibold text-gray-700">${text}</h5>`;
+    };
+
+    renderer.paragraph = function (text) {
+      return `<p class="my-2.5 text-sm leading-relaxed text-gray-600">${text}</p>`;
+    };
+
+    renderer.list = function (body, ordered, start) {
+      const tag: string = ordered ? "ol" : "ul";
+      const cls: string = ordered
+        ? "list-decimal pl-5 my-2 space-y-1.5 text-sm text-gray-600 marker:text-gray-400"
+        : "list-disc pl-5 my-2 space-y-1.5 text-sm text-gray-600 marker:text-gray-300";
+      const startAttr: string =
+        ordered && start !== 1 ? ` start="${start}"` : "";
+      return `<${tag}${startAttr} class="${cls}">${body}</${tag}>`;
+    };
+    renderer.listitem = function (text) {
+      return `<li class="leading-relaxed pl-1">${text}</li>`;
+    };
+
+    renderer.strong = function (text) {
+      return `<strong class="font-semibold text-gray-800">${text}</strong>`;
+    };
+    renderer.em = function (text) {
+      return `<em class="italic">${text}</em>`;
+    };
+
+    renderer.blockquote = function (quote) {
+      return `<blockquote class="my-3 border-s-2 border-emerald-200 ps-3 text-sm text-gray-600">${quote}</blockquote>`;
+    };
+
+    renderer.hr = function () {
+      return '<hr class="my-5 border-t border-gray-100" />';
+    };
+
+    renderer.codespan = function (code) {
+      const escaped: string = Markdown.escapeHtml(code);
+      return `<code class="rounded bg-gray-100 px-1.5 py-0.5 text-[0.8125rem] text-gray-700 font-mono break-words">${escaped}</code>`;
+    };
+
+    renderer.code = function (code, language) {
+      const escaped: string = Markdown.escapeHtml(code);
+      return `<pre class="my-3 overflow-x-auto rounded-lg bg-gray-50 border border-gray-100 p-3 text-xs leading-relaxed"><code class="language-${language} font-mono text-gray-700">${escaped}</code></pre>`;
+    };
+
+    renderer.table = function (header, body) {
+      return `<div class="my-4 overflow-x-auto rounded-lg border border-gray-100"><table class="min-w-full text-sm text-left">${header}${body}</table></div>`;
+    };
+    renderer.tablerow = function (content) {
+      return `<tr class="border-b border-gray-100 last:border-b-0">${content}</tr>`;
+    };
+    renderer.tablecell = function (content, flags) {
+      const tag: string = flags.header ? "th" : "td";
+      const align: string = flags.align ? ` text-${flags.align}` : "";
+      const headerClass: string = flags.header
+        ? " font-semibold text-gray-900 bg-gray-50"
+        : " text-gray-600";
+      return `<${tag} class="px-3 py-2${align}${headerClass}">${content}</${tag}>`;
+    };
+
+    renderer.link = function (href, _title, text) {
+      if (!href) {
+        return text as string;
+      }
+      const isExternal: boolean = href.startsWith("http");
+      const rel: string = isExternal
+        ? ' target="_blank" rel="noopener noreferrer"'
+        : "";
+      return `<a href="${href}"${rel} class="text-emerald-700 font-medium underline decoration-emerald-200 underline-offset-2 hover:decoration-emerald-400 break-words">${text}</a>`;
+    };
+
+    this.blogValidationRenderer = renderer;
+
+    return renderer;
+  }
+
   private static slugify(text: string): string {
     return text
       .toLowerCase()

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -193,8 +193,11 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
     return record;
   }
 
-  private escapeStringLiteral(raw: string): string {
+  private escapeStringLiteral(raw: string | undefined | null): string {
     // escape String literal based on https://clickhouse.com/docs/en/sql-reference/syntax#string
+    if (raw === undefined || raw === null) {
+      return "''";
+    }
     return `'${raw.replace(/'|\\/g, "\\$&")}'`;
   }
 

package/Server/Utils/CodeRepository/CodeRepository.ts

@@ -385,6 +385,84 @@ export default class CodeRepositoryUtil {
     return hash.trim();
   }
 
+  /**
+   * Returns the author (name + email) and the list of files changed for every
+   * non-merge commit in the repository, newest first. Optionally limited to a
+   * pathspec (e.g. "posts"). Used to derive per-directory contributors.
+   *
+   * Note: a shallow clone (`--depth 1`) only has the latest commit, so this
+   * returns a single contributor unless the repo was cloned with history.
+   */
+  @CaptureSpan()
+  public static async getCommitAuthorsWithFiles(data: {
+    repoPath: string;
+    path?: string | undefined;
+  }): Promise<
+    Array<{
+      authorName: string;
+      authorEmail: string;
+      files: Array<string>;
+    }>
+  > {
+    /*
+     * ASCII record (0x1e) / unit (0x1f) separators never occur in author names,
+     * emails or file paths, so they delimit commits and fields unambiguously.
+     */
+    const recordSeparator: string = "\x1e";
+    const unitSeparator: string = "\x1f";
+
+    const args: Array<string> = [
+      "log",
+      "--no-merges",
+      `--pretty=format:${recordSeparator}%an${unitSeparator}%ae`,
+      "--name-only",
+    ];
+
+    if (data.path) {
+      args.push("--", data.path);
+    }
+
+    const stdout: string = await Execute.executeCommandFile({
+      command: "git",
+      args,
+      cwd: path.resolve(data.repoPath),
+      // git log over a full repo can easily exceed the 1 MB default.
+      maxBuffer: 256 * 1024 * 1024,
+    });
+
+    const commits: Array<{
+      authorName: string;
+      authorEmail: string;
+      files: Array<string>;
+    }> = [];
+
+    for (const record of stdout.split(recordSeparator)) {
+      if (!record.trim()) {
+        continue;
+      }
+
+      const lines: Array<string> = record.split("\n");
+      const header: string = lines.shift() || "";
+      const [authorName, authorEmail] = header.split(unitSeparator);
+
+      const files: Array<string> = lines
+        .map((line: string) => {
+          return line.trim();
+        })
+        .filter((line: string) => {
+          return line.length > 0;
+        });
+
+      commits.push({
+        authorName: (authorName || "").trim(),
+        authorEmail: (authorEmail || "").trim(),
+        files,
+      });
+    }
+
+    return commits;
+  }
+
   @CaptureSpan()
   public static async listFilesInDirectory(data: {
     directoryPath: string;

package/Server/Utils/Execute.ts

@@ -54,6 +54,11 @@ export default class Execute {
     command: string;
     args: Array<string>;
     cwd: string;
+    /*
+     * Override the child_process default stdout/stderr cap (1 MB). Commands that
+     * can emit large output (e.g. `git log` over a whole repo) should raise this.
+     */
+    maxBuffer?: number | undefined;
   }): Promise<string> {
     return new Promise(
       (
@@ -65,6 +70,7 @@ export default class Execute {
           data.args,
           {
             cwd: data.cwd,
+            ...(data.maxBuffer ? { maxBuffer: data.maxBuffer } : {}),
           },
           (err: ExecException | null, stdout: string, stderr: string) => {
             if (err) {