@oneuptime/common 11.0.12 → 11.0.13

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/Index.ts

@@ -398,6 +398,7 @@ 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";
 
 export default [
   InitialMigration,
@@ -800,4 +801,5 @@ export default [
   RemoveIsTestedFromGlobalSsoAndOidc1782400000000,
   OptimizeTelemetryExceptionWritePath1782500000000,
   AddArchiveToResources1782600000000,
+  RemoveDeprecatedEnableSubscribersFromStatusPage1782700000000,
 ];

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/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) {

package/Server/Utils/Logger.ts

@@ -8,6 +8,12 @@ import ConfigLogLevel from "../Types/ConfigLogLevel";
 
 export type LogBody = string | JSONObject | Exception | Error | unknown;
 
+export interface RecentLogEntry {
+  time: string;
+  level: string;
+  message: string;
+}
+
 export interface LogAttributes {
   userId?: string | undefined;
   projectId?: string | undefined;
@@ -50,6 +56,56 @@ export function getLogAttributesFromRequest(
 }
 
 export default class logger {
+  /*
+   * In-memory ring buffer of the most recent log lines this process emitted.
+   * The app writes logs to stdout only (no on-disk file), so this is the one
+   * way the master-admin support bundle / health dashboard can surface this
+   * instance's own recent logs for debugging — there is no path to the
+   * container's stdout or to other containers' logs from inside the process.
+   */
+  private static recentLogs: Array<RecentLogEntry> = [];
+  private static readonly maxRecentLogs: number = 1000;
+  private static readonly recentLogTrimSlack: number = 256;
+  private static readonly maxRecentLogMessageLength: number = 4000;
+
+  private static record(level: string, body: LogBody): void {
+    try {
+      const message: string = this.serializeLogBody(body);
+
+      this.recentLogs.push({
+        time: new Date().toISOString(),
+        level: level,
+        message:
+          message.length > this.maxRecentLogMessageLength
+            ? `${message.substring(0, this.maxRecentLogMessageLength)}… (truncated)`
+            : message,
+      });
+
+      /*
+       * Trim in batches rather than on every push so this stays O(1) amortised
+       * on the logging hot path: only re-slice once we have grown past a soft
+       * ceiling above the target size.
+       */
+      if (
+        this.recentLogs.length >
+        this.maxRecentLogs + this.recentLogTrimSlack
+      ) {
+        this.recentLogs = this.recentLogs.slice(-this.maxRecentLogs);
+      }
+    } catch {
+      // Never let log capture break the app.
+    }
+  }
+
+  // Newest-last snapshot of the recent-log ring buffer (optionally the last N).
+  public static getRecentLogs(limit?: number): Array<RecentLogEntry> {
+    if (!limit || limit >= this.recentLogs.length) {
+      return [...this.recentLogs];
+    }
+
+    return this.recentLogs.slice(this.recentLogs.length - limit);
+  }
+
   public static getLogLevel(): ConfigLogLevel {
     if (!LogLevel) {
       return ConfigLogLevel.INFO;
@@ -98,6 +154,8 @@ export default class logger {
       // eslint-disable-next-line no-console
       console.info(message);
 
+      this.record("INFO", message);
+
       this.emit({
         body: message,
         severityNumber: SeverityNumber.INFO,
@@ -118,6 +176,8 @@ export default class logger {
       // eslint-disable-next-line no-console
       console.error(message);
 
+      this.record("ERROR", message);
+
       this.emit({
         body: message,
         severityNumber: SeverityNumber.ERROR,
@@ -137,6 +197,8 @@ export default class logger {
       // eslint-disable-next-line no-console
       console.warn(message);
 
+      this.record("WARN", message);
+
       this.emit({
         body: message,
         severityNumber: SeverityNumber.WARN,
@@ -152,6 +214,8 @@ export default class logger {
       // eslint-disable-next-line no-console
       console.debug(message);
 
+      this.record("DEBUG", message);
+
       this.emit({
         body: message,
         severityNumber: SeverityNumber.DEBUG,
@@ -203,6 +267,8 @@ export default class logger {
       // eslint-disable-next-line no-console
       console.trace(message);
 
+      this.record("TRACE", message);
+
       this.emit({
         body: message,
         severityNumber: SeverityNumber.DEBUG,

package/Tests/Server/Utils/AnalyticsDatabase/StatementGenerator.test.ts

@@ -636,6 +636,81 @@ describe("StatementGenerator", () => {
     });
   });
 
+  describe("toCreateStatement", () => {
+    /*
+     * Regression test for the escapeStringLiteral undefined/null guard.
+     * An ArrayText (Array(String)) column whose value array carried
+     * undefined/null members at runtime used to throw
+     * "TypeError: Cannot read properties of undefined (reading 'replace')"
+     * inside escapeStringLiteral while building the INSERT. The member is
+     * now rendered as the empty string literal '' so the statement still
+     * serializes to a valid ClickHouse Array(String).
+     */
+    class ArrayTextModel extends AnalyticsBaseModel {
+      public constructor() {
+        super({
+          tableName: "<array-create-table>",
+          singularName: "<singular>",
+          pluralName: "<plural>",
+          tableColumns: [
+            new AnalyticsTableColumn({
+              key: "_id",
+              title: "<title>",
+              description: "<description>",
+              required: true,
+              type: TableColumnType.ObjectID,
+            }),
+            new AnalyticsTableColumn({
+              key: "entityKeys",
+              title: "<title>",
+              description: "<description>",
+              required: true,
+              defaultValue: [],
+              type: TableColumnType.ArrayText,
+            }),
+          ],
+          crudApiPath: new Route("route"),
+          primaryKeys: ["_id"],
+          sortKeys: ["_id"],
+          partitionKey: "_id",
+          tableEngine: AnalyticsTableEngine.MergeTree,
+        });
+      }
+    }
+
+    let arrayTextGenerator: StatementGenerator<ArrayTextModel>;
+    beforeEach(() => {
+      arrayTextGenerator = new StatementGenerator<ArrayTextModel>({
+        modelType: ArrayTextModel,
+        database: ClickhouseAppInstance,
+      });
+    });
+
+    test("renders undefined/null ArrayText elements as '' instead of throwing", () => {
+      const item: ArrayTextModel = new ArrayTextModel();
+      item.setColumnValue("_id", "210dac24142f1baa");
+      /*
+       * Simulate runtime data where the Array(String) column carries
+       * undefined/null members. The type system models the column as
+       * string[], hence the cast — this is exactly what crashed before
+       * the guard was added.
+       */
+      item.setColumnValue("entityKeys", [
+        "alpha",
+        undefined,
+        null,
+        "beta",
+      ] as unknown as Array<string>);
+
+      let statement: string = "";
+      expect(() => {
+        statement = arrayTextGenerator.toCreateStatement({ item: [item] });
+      }).not.toThrow();
+
+      expect(statement).toContain("['alpha', '', '', 'beta']");
+    });
+  });
+
   describe("toSelectStatement", () => {
     test("should return the contents of a SELECT statement", () => {
       const { statement, columns } = generator.toSelectStatement({