@oneuptime/common 11.0.10 → 11.0.13

package/Server/Services/KubernetesClusterService.ts

@@ -193,12 +193,14 @@ export class Service extends DatabaseService<Model> {
       data.agentVersion = extra.agentVersion;
     }
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write: a single-statement UPDATE with no hooks and no
+     * `version` bump, avoiding the hot-row Postgres lock convoy that the
+     * full updateOneById pipeline causes. See ServiceService.updateLastSeen.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: clusterId,
       data: data,
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Services/PodmanHostService.ts

@@ -236,12 +236,14 @@ export class Service extends DatabaseService<Model> {
       data.agentVersion = extra.agentVersion;
     }
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write: a single-statement UPDATE with no hooks and no
+     * `version` bump, avoiding the hot-row Postgres lock convoy that the
+     * full updateOneById pipeline causes. See ServiceService.updateLastSeen.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: hostId,
       data: data,
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Services/ProbeService.ts

@@ -120,14 +120,20 @@ export class Service extends DatabaseService<Model> {
 
     const now: Date = OneUptimeDate.getCurrentDate();
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write: a single-statement UPDATE with no hooks and no
+     * `version` bump. This fires from the probe-auth middleware on every
+     * authenticated probe request, so it must not head the hot-row Postgres
+     * lock convoy the full updateOneById pipeline causes. A lastAlive-only
+     * write never sets connectionStatus, so the connection-status-change
+     * hooks (onBeforeUpdate/onUpdateSuccess) are inert here. See
+     * ServiceService.updateLastSeen.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: probeId,
       data: {
         lastAlive: now,
       },
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Services/ProxmoxClusterService.ts

@@ -250,12 +250,14 @@ export class Service extends DatabaseService<Model> {
       data.guestsWithoutBackupCount = extra.guestsWithoutBackupCount;
     }
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write: a single-statement UPDATE with no hooks and no
+     * `version` bump, avoiding the hot-row Postgres lock convoy that the
+     * full updateOneById pipeline causes. See ServiceService.updateLastSeen.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: clusterId,
       data: data,
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Services/RumApplicationService.ts

@@ -185,12 +185,14 @@ export class Service extends DatabaseService<Model> {
       data.sdkLanguage = extra.sdkLanguage;
     }
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write: a single-statement UPDATE with no hooks and no
+     * `version` bump, avoiding the hot-row Postgres lock convoy that the
+     * full updateOneById pipeline causes. See ServiceService.updateLastSeen.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: rumApplicationId,
       data: data,
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Services/ServerlessFunctionService.ts

@@ -229,12 +229,14 @@ export class Service extends DatabaseService<Model> {
       data.runtimeVersion = extra.runtimeVersion;
     }
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write: a single-statement UPDATE with no hooks and no
+     * `version` bump, avoiding the hot-row Postgres lock convoy that the
+     * full updateOneById pipeline causes. See ServiceService.updateLastSeen.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: serverlessFunctionId,
       data: data,
-      props: {
-        isRoot: true,
-      },
     });
   }
 

package/Server/Services/ServiceService.ts

@@ -198,12 +198,25 @@ export class Service extends DatabaseService<Model> {
       data.cloudAccountId = extra.cloudAccountId;
     }
 
-    await this.updateOneById({
+    /*
+     * Heartbeat write. This is the single hottest UPDATE in the system —
+     * every telemetry batch for a service re-resolves the same serviceId —
+     * so it must NOT go through the full updateOneById pipeline (permission
+     * SELECT -> _findBy SELECT -> save() with `version = version + 1` ->
+     * workflow/realtime/audit hooks). That pipeline holds the Service row's
+     * write lock across several round trips and, when an event loop stalls
+     * mid-`save()` transaction, leaves it open as the head of a lock convoy
+     * that starves the Postgres connection pool. lastSeenAt is an internal
+     * liveness timestamp with no onBeforeUpdate/onUpdateSuccess hooks on this
+     * model (connected / disconnected status is derived from it at read
+     * time), so a bare single-statement UPDATE is both correct and far
+     * cheaper. This also intentionally drops the per-update workflow trigger
+     * Service's @EnableWorkflow({ update: true }) fired on every heartbeat —
+     * a liveness ping should not trigger user workflows.
+     */
+    await this.updateColumnsByIdWithoutHooks({
       id: serviceId,
       data: data,
-      props: {
-        isRoot: true,
-      },
     });
   }
 

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

@@ -87,7 +87,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
       .append(setStatement)
       .append(
         SQL`
-            WHERE TRUE `
+            WHERE TRUE `,
       )
       .append(whereStatement);
     /* eslint-enable prettier/prettier */
@@ -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/Server/Utils/Monitor/MonitorResource.ts

@@ -316,17 +316,27 @@ export default class MonitorResourceUtil {
            * the monitor to flap between Online and Offline every minute.
            */
           if (!serverMonitorResponse.onlyCheckRequestReceivedAt) {
-            await MonitorService.updateOneById({
+            /*
+             * Heartbeat write: single-statement UPDATE, no hooks and no
+             * `version` bump. This DELIBERATELY drops the per-update workflow
+             * trigger and audit-log entry that Monitor's @EnableWorkflow /
+             * @EnableAuditLog fire on every changed update — the old
+             * `ignoreHooks: true` did NOT suppress those (they are gated on
+             * the model flag, not on ignoreHooks), so a heartbeat used to
+             * spam an on-update workflow + an audit row every ingest. A
+             * liveness ping should do neither. onUpdateSuccess is inert here
+             * regardless (gated on status/interval/steps/name/etc., none of
+             * which are written). Also skips the pre-SELECT that would reload
+             * the large serverMonitorResponse jsonb row. See
+             * ServiceService.updateLastSeen.
+             */
+            await MonitorService.updateColumnsByIdWithoutHooks({
               id: monitor.id!,
               data: {
                 serverMonitorRequestReceivedAt:
                   serverMonitorResponse.requestReceivedAt!,
                 serverMonitorResponse,
               },
-              props: {
-                isRoot: true,
-                ignoreHooks: true,
-              },
             });
 
             logger.debug(
@@ -344,7 +354,15 @@ export default class MonitorResourceUtil {
             `${dataToProcess.monitorId.toString()} - Incoming request received at ${incomingMonitorRequest.incomingRequestReceivedAt}`,
           );
 
-          await MonitorService.updateOneById({
+          /*
+           * Heartbeat write: single-statement UPDATE, no hooks and no
+           * `version` bump. As with the server-monitor branch above, this
+           * deliberately drops the per-update workflow trigger + audit-log
+           * entry Monitor would otherwise fire on every heartbeat, and skips
+           * the pre-SELECT of the large incomingMonitorRequest jsonb row. See
+           * ServiceService.updateLastSeen.
+           */
+          await MonitorService.updateColumnsByIdWithoutHooks({
             id: monitor.id!,
             data: {
               incomingRequestMonitorHeartbeatCheckedAt:
@@ -353,10 +371,6 @@ export default class MonitorResourceUtil {
                 JSON.stringify(incomingMonitorRequest),
               ) as IncomingMonitorRequest,
             } as any,
-            props: {
-              isRoot: true,
-              ignoreHooks: true,
-            },
           });
 
           logger.debug(

package/Server/Utils/Telemetry/EntityRegistry.ts

@@ -271,11 +271,17 @@ export async function reconcileByNaturalKey<
   });
 
   if (existing) {
-    // Throttled bump of lastSeenAt (+ any caller-supplied merge fields).
-    await data.service.updateOneById({
+    /*
+     * Throttled bump of lastSeenAt (+ any caller-supplied merge fields).
+     * Heartbeat write: single-statement UPDATE, no hooks and no `version`
+     * bump (TelemetryEntity/Relationship enable no update workflow/realtime/
+     * audit). buildBump returns only plain values — lastSeenAt plus, at most,
+     * the descriptiveAttributes / labels JSON columns — which the primitive
+     * persists via the driver transformer path. See ServiceService.updateLastSeen.
+     */
+    await data.service.updateColumnsByIdWithoutHooks({
       id: existing.id!,
       data: buildBump(existing),
-      props: { isRoot: true },
     });
     return;
   }
@@ -306,10 +312,9 @@ export async function reconcileByNaturalKey<
       logger.debug(
         `EntityRegistry: create raced for ${data.describe} (concurrent insert); bumping lastSeenAt on the winning row.`,
       );
-      await data.service.updateOneById({
+      await data.service.updateColumnsByIdWithoutHooks({
         id: winner.id!,
         data: buildBump(winner),
-        props: { isRoot: true },
       });
       return;
     }