@oneuptime/common 11.5.12 → 11.6.0

package/Models/DatabaseModels/AIInsight.ts

@@ -205,6 +205,36 @@ export default class AIInsight extends BaseModel {
   })
   public severity?: AIInsightSeverity = undefined;
 
+  /*
+   * Triage verdict (ExceptionAIClassification values) written by the
+   * insight triage runner. Null until triage completes. The automatic
+   * fix lane only opens pull requests for insights triaged as
+   * code-fault — see InsightScanner / InsightFixRouting.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortText,
+    title: "Classification",
+    description:
+      "AI triage verdict: code-fault, user-error, expected-denial, infrastructure or unknown. Automatic fix pull requests are only opened for code-fault.",
+    canReadOnRelationQuery: true,
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public classification?: string = undefined;
+
   /*
    * The detector's stable dedupe key for this finding (e.g.
    * "new-exception:<telemetryExceptionId>"). The scanner refreshes the

package/Models/DatabaseModels/EnterpriseLicense.ts

@@ -102,6 +102,27 @@ export default class EnterpriseLicense extends BaseModel {
   })
   public annualContractValue?: number = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: true,
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    title: "Evaluation License",
+    description:
+      "When enabled, this key is for evaluation and testing only — the customer's installation shows an evaluation notice and it is not meant for production use.",
+    defaultValue: false,
+  })
+  @Column({
+    nullable: false,
+    type: ColumnType.Boolean,
+    default: false,
+  })
+  public isEvaluationLicense?: boolean = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [],

package/Models/DatabaseModels/EnterpriseLicenseInstance.ts

@@ -188,4 +188,29 @@ export default class EnterpriseLicenseInstance extends BaseModel {
     nullable: true,
   })
   public masterAdminEmails?: Array<string> = undefined;
+
+  /*
+   * Named oneuptimeVersion, not version: DatabaseBaseModel already declares a
+   * `version` @VersionColumn() (the optimistic-locking row revision) on every
+   * model, so a second `version` property would collide in the TypeORM entity
+   * metadata.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.ShortText,
+    title: "OneUptime Version",
+    description:
+      "OneUptime version this instance last reported, for example 11.5.13. Lets support see which instances are running an outdated build.",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public oneuptimeVersion?: string = undefined;
 }

package/Models/DatabaseModels/GlobalConfig.ts

@@ -824,6 +824,25 @@ export default class GlobalConfig extends GlobalConfigModel {
   })
   public enterpriseLicenseToken?: string = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.Boolean,
+    title: "Enterprise License Is Evaluation",
+    description:
+      "True when the validated enterprise license is an evaluation/testing license. Drives the evaluation notice shown in the edition modal.",
+    defaultValue: false,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: true,
+    default: false,
+  })
+  public enterpriseLicenseIsEvaluation?: boolean = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [],
@@ -929,6 +948,63 @@ export default class GlobalConfig extends GlobalConfigModel {
   })
   public enterpriseLicenseExpiryReminderDays?: number = undefined;
 
+  /*
+   * The four latestRelease* columns cache the daily GitHub release check
+   * (Workers/Jobs/InstanceUpdate/CheckForNewVersion). They are a cache, not
+   * configuration: an air-gapped installation simply leaves them null and no
+   * update prompt is ever shown.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ShortText,
+    title: "Latest Release Version",
+    description:
+      "Latest OneUptime version published on GitHub, for example 11.6.0, as of the last update check. Null until the first successful check.",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: true,
+  })
+  public latestReleaseVersion?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.Date,
+    title: "Latest Release Published At",
+    description: "When the latest OneUptime version was published on GitHub.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public latestReleasePublishedAt?: Date = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.Date,
+    title: "Latest Release Checked At",
+    description:
+      "When this installation last successfully checked GitHub for a newer OneUptime release.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public latestReleaseCheckedAt?: Date = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [],

package/Models/DatabaseModels/Project.ts

@@ -1599,6 +1599,36 @@ export default class Project extends TenantModel {
   })
   public enableInsightFixTasks?: boolean = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.ReadProject,
+      Permission.UnAuthorizedSsoUser,
+      Permission.ProjectUser,
+    ],
+    update: [Permission.ProjectOwner, Permission.ProjectAdmin],
+  })
+  @TableColumn({
+    required: true,
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    title: "Auto Archive Non-Actionable Exceptions",
+    description:
+      "When enabled, exception groups the AI triage classifies as expected denials (auth failures, plan/paywall rejections, scanner probes tripping intentional validation) are automatically archived so they stop surfacing in the unresolved list and never queue AI fix tasks. Groups classified as user errors or infrastructure conditions are NOT auto-archived — only clear expected denials are. Archiving is reversible from the Archived tab.",
+    defaultValue: false,
+    example: true,
+  })
+  @Column({
+    nullable: false,
+    default: false,
+    type: ColumnType.Boolean,
+  })
+  public autoArchiveNonActionableExceptions?: boolean = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [

package/Models/DatabaseModels/TelemetryException.ts

@@ -1281,4 +1281,132 @@ export default class TelemetryException extends DatabaseBaseModel {
     length: ColumnLength.LongText,
   })
   public environment?: string = undefined;
+
+  @ColumnAccessControl({
+    /*
+     * Server-written only (isRoot bypasses column ACL): this is derived
+     * state maintained by ingest / triage / the PR-state sync — a client
+     * PATCH must not be able to set it (the value flows into LLM prompts
+     * and public PR text, and it gates the automatic fix lane).
+     */
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.TelemetryAdmin,
+      Permission.TelemetryMember,
+      Permission.TelemetryViewer,
+      Permission.ReadTelemetryException,
+    ],
+    update: [],
+  })
+  /*
+   * Sticky rollup of the OTel exception.escaped flag: true once ANY
+   * occurrence of this group escaped its span scope (was unhandled).
+   * Maintained by the ingest upsert with `unhandled OR EXCLUDED.unhandled`
+   * — a group never flips back to handled. Handled exceptions are usually
+   * expected/operational errors, which is a key signal for deciding
+   * whether an AI fix PR is warranted.
+   */
+  @TableColumn({
+    title: "Unhandled",
+    description:
+      "True when at least one occurrence of this exception escaped its span scope (was unhandled, per OTel exception.escaped)",
+    isDefaultValueColumn: true,
+    required: true,
+    type: TableColumnType.Boolean,
+    defaultValue: false,
+    example: true,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    unique: false,
+    default: false,
+  })
+  public unhandled?: boolean = undefined;
+
+  @ColumnAccessControl({
+    /*
+     * Server-written only (isRoot bypasses column ACL): this is derived
+     * state maintained by ingest / triage / the PR-state sync — a client
+     * PATCH must not be able to set it (the value flows into LLM prompts
+     * and public PR text, and it gates the automatic fix lane).
+     */
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.TelemetryAdmin,
+      Permission.TelemetryMember,
+      Permission.TelemetryViewer,
+      Permission.ReadTelemetryException,
+    ],
+    update: [],
+  })
+  /*
+   * Verdict of the AI insight triage for this exception group: is this a
+   * code defect the AI should try to fix, an expected end-user error, an
+   * expected denial (auth/paywall/probe), or an infrastructure condition?
+   * Values come from ExceptionAIClassification. Written by the triage
+   * runner; the automatic fix lane only opens PRs for CodeFault groups.
+   */
+  @TableColumn({
+    title: "AI Classification",
+    description:
+      "AI triage verdict for this exception group (code-fault, user-error, expected-denial, infrastructure)",
+    required: false,
+    type: TableColumnType.ShortText,
+    example: "code-fault",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+  })
+  public aiClassification?: string = undefined;
+
+  @ColumnAccessControl({
+    /*
+     * Server-written only (isRoot bypasses column ACL): this is derived
+     * state maintained by ingest / triage / the PR-state sync — a client
+     * PATCH must not be able to set it (the value flows into LLM prompts
+     * and public PR text, and it gates the automatic fix lane).
+     */
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.TelemetryAdmin,
+      Permission.TelemetryMember,
+      Permission.TelemetryViewer,
+      Permission.ReadTelemetryException,
+    ],
+    update: [],
+  })
+  /*
+   * Stamped when a human closes an AI-authored fix PR for this exception
+   * without merging it — the strongest "the AI fix was not wanted" signal.
+   * The automatic fix lane skips groups carrying this stamp; a human
+   * clicking "Fix with AI" on the exception page clears it and retries.
+   */
+  @TableColumn({
+    title: "AI Fix Declined At",
+    description:
+      "Set when an AI-authored fix pull request for this exception was closed without merging; suppresses further automatic fix attempts",
+    required: false,
+    type: TableColumnType.Date,
+    example: "2026-01-01T00:00:00.000Z",
+  })
+  @Column({
+    nullable: true,
+    type: ColumnType.Date,
+  })
+  public aiFixDeclinedAt?: Date = undefined;
 }

package/Server/API/AIAgentDataAPI.ts

@@ -43,6 +43,11 @@ import CodeFixTaskContext, {
   PerformanceFinding,
 } from "../../Types/AI/CodeFixTaskContext";
 import SpanTreeAnalyzer from "../Utils/AI/PerfEvidence/SpanTreeAnalyzer";
+import {
+  sanitizeExceptionMessage,
+  sanitizeStackTrace,
+} from "../Utils/Telemetry/ExceptionSanitizer";
+import ToolResultSerializer from "../Utils/AI/Toolbox/Serializer";
 import OpenPullRequestCap, {
   OpenPullRequestCapDecision,
 } from "../Utils/AI/CodeFix/OpenPullRequestCap";
@@ -204,6 +209,7 @@ export default class AIAgentDataAPI {
                 stackTrace: true,
                 exceptionType: true,
                 fingerprint: true,
+                aiClassification: true,
                 primaryEntityId: true,
                 primaryEntityType: true,
               },
@@ -221,7 +227,7 @@ export default class AIAgentDataAPI {
           }
 
           logger.debug(
-            `Exception details fetched: ${exception._id} - ${exception.message?.substring(0, 100)}`,
+            `Exception details fetched: ${exception._id}`,
             getLogAttributesFromRequest(req as any),
           );
 
@@ -245,13 +251,24 @@ export default class AIAgentDataAPI {
               })
             : null;
 
+          /*
+           * Sanitize at the choke point: everything the AI agent worker
+           * sees — and therefore everything that can end up in an LLM
+           * prompt, a public pull-request title/body, or a commit
+           * message — flows through this response. The message gets
+           * dynamic-token normalization + secret redaction; the stack
+           * trace gets redaction only, so file:line frames stay intact
+           * for the code agent.
+           */
           return Response.sendJsonObjectResponse(req, res, {
             exception: {
               id: exception._id?.toString(),
-              message: exception.message,
-              stackTrace: exception.stackTrace,
-              exceptionType: exception.exceptionType,
+              message: sanitizeExceptionMessage(exception.message || ""),
+              stackTrace: sanitizeStackTrace(exception.stackTrace || ""),
+              // Legacy pre-batch-upsert rows can carry NULL here.
+              exceptionType: exception.exceptionType || "",
               fingerprint: exception.fingerprint,
+              aiClassification: exception.aiClassification || null,
             },
             service: exception.primaryEntityId
               ? {
@@ -518,6 +535,103 @@ export default class AIAgentDataAPI {
             );
           }
 
+          /*
+           * Service-scoped instrumentation recipes (ImproveLogging /
+           * ImproveTracing): the context is just the service — resolve the
+           * repository by service name (no stack trace) and hand the
+           * worker a short brief; the recipe's checklist lives in the
+           * worker's prompt.
+           */
+          if (
+            taskType === CodeFixTaskType.ImproveLogging ||
+            taskType === CodeFixTaskType.ImproveTracing
+          ) {
+            const taskContext: CodeFixTaskContext | undefined = run.taskContext;
+            const improvementServiceName: string =
+              taskContext?.serviceName || "";
+
+            if (!taskContext?.telemetryServiceId) {
+              return Response.sendErrorResponse(
+                req,
+                res,
+                new BadDataException(
+                  "This telemetry-improvement task has no stored service context — the task has nothing to work from.",
+                ),
+              );
+            }
+
+            const pillar: string =
+              taskType === CodeFixTaskType.ImproveLogging
+                ? "logging"
+                : "tracing";
+            const subjectTitle: string = improvementServiceName
+              ? `Improve ${pillar} for ${improvementServiceName}`
+              : `Improve ${pillar}`;
+
+            const resolution: RepoResolution | null =
+              await CodeRepositoryService.resolveRepositoryForException({
+                projectId: run.projectId,
+                stackTrace: null,
+                serviceName: improvementServiceName || null,
+              });
+
+            const repository: CodeRepository | null = resolution
+              ? await CodeRepositoryService.findOneById({
+                  id: new ObjectID(resolution.codeRepositoryId),
+                  select: {
+                    _id: true,
+                    name: true,
+                    repositoryHostedAt: true,
+                    organizationName: true,
+                    repositoryName: true,
+                    mainBranchName: true,
+                    gitHubAppInstallationId: true,
+                  },
+                  props: { isRoot: true },
+                })
+              : null;
+
+            const basePayload: JSONObject = {
+              subjectType: "service",
+              subjectTitle,
+              analysisMarkdown: `OneUptime observes the telemetry of the service ${
+                improvementServiceName
+                  ? `"${improvementServiceName}"`
+                  : "in this repository"
+              }. A user asked for its ${pillar} instrumentation to be improved — follow the task checklist in your instructions.`,
+              serviceName: improvementServiceName,
+              projectId: run.projectId.toString(),
+            };
+
+            if (!resolution || !repository) {
+              return Response.sendJsonObjectResponse(req, res, {
+                ...basePayload,
+                repositories: [],
+                resolutionError:
+                  "Could not resolve a repository for this task: no connected repository name matches the service and the project has more than one repository. Connect the right repository via the GitHub App, or rename one to match the service.",
+              });
+            }
+
+            return Response.sendJsonObjectResponse(req, res, {
+              ...basePayload,
+              repositories: [
+                {
+                  id: repository.id!.toString(),
+                  name: repository.name || "",
+                  repositoryHostedAt: repository.repositoryHostedAt || "",
+                  organizationName: repository.organizationName || "",
+                  repositoryName: repository.repositoryName || "",
+                  mainBranchName: repository.mainBranchName || "main",
+                  servicePathInRepository: resolution.servicePathInRepository,
+                  gitHubAppInstallationId:
+                    repository.gitHubAppInstallationId || null,
+                  resolutionMethod: resolution.method,
+                  resolutionEvidence: resolution.evidence,
+                },
+              ],
+            });
+          }
+
           /*
            * Trace-evidence recipes (FixPerformance): everything the worker
            * needs was captured into taskContext at trigger time — the spans
@@ -607,8 +721,10 @@ export default class AIAgentDataAPI {
             const basePayload: JSONObject = {
               subjectType: "trace",
               subjectTitle: findings[0]!.headline,
-              analysisMarkdown:
+              // Redact before it can reach a prompt or PR body.
+              analysisMarkdown: ToolResultSerializer.redact(
                 SpanTreeAnalyzer.renderFindingsMarkdown(findings),
+              ).text,
               serviceName,
               projectId: run.projectId.toString(),
               traceId: taskContext.traceId,
@@ -788,6 +904,14 @@ export default class AIAgentDataAPI {
             );
           }
 
+          /*
+           * The analysis was written by the investigation LLM over
+           * redacted tool results, but quoted exception text can still
+           * carry secrets — sweep it again before it reaches the worker's
+           * prompt and the pull-request body.
+           */
+          analysisMarkdown = ToolResultSerializer.redact(analysisMarkdown).text;
+
           /*
            * Resolve the repository WITHOUT a stack trace — these tasks have
            * no exception, so only the name-match (against the subject's

package/Server/API/AIInvestigationAPI.ts

@@ -31,6 +31,8 @@ import ServiceService from "../Services/ServiceService";
 import SpanService from "../Services/SpanService";
 import FixFromIncidentTaskTrigger from "../Utils/AI/SRE/FixFromIncidentTaskTrigger";
 import FixPerformanceTaskTrigger from "../Utils/AI/SRE/FixPerformanceTaskTrigger";
+import TelemetryImprovementTaskTrigger from "../Utils/AI/SRE/TelemetryImprovementTaskTrigger";
+import CodeFixTaskType from "../../Types/AI/CodeFixTaskType";
 import { AnalyzableSpan } from "../Utils/AI/PerfEvidence/SpanTreeAnalyzer";
 
 const router: ExpressRouter = Express.getRouter();
@@ -575,4 +577,89 @@ router.post(
   },
 );
 
+/*
+ * "Improve logging / tracing with AI" from a telemetry service's Logs or
+ * Traces page: gate and enqueue a service-scoped instrumentation-
+ * improvement CodeFix run (ImproveLogging / ImproveTracing). Human-
+ * triggered — the click is the gate; budget, repository and per-service
+ * dedupe are enforced in the trigger. Returns { aiRunId }.
+ */
+router.post(
+  "/ai-investigation/create-telemetry-improvement-task",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const props: DatabaseCommonInteractionProps = await getLoggedInProps(req);
+
+      const projectId: ObjectID | undefined = props.tenantId;
+
+      if (!projectId) {
+        throw new BadDataException("A project scope is required.");
+      }
+
+      const telemetryServiceIdParam: string | undefined = req.body[
+        "telemetryServiceId"
+      ] as string | undefined;
+
+      if (!telemetryServiceIdParam) {
+        throw new BadDataException("telemetryServiceId is required.");
+      }
+
+      const rawTaskType: string | undefined = req.body["taskType"] as
+        | string
+        | undefined;
+
+      if (
+        rawTaskType !== CodeFixTaskType.ImproveLogging &&
+        rawTaskType !== CodeFixTaskType.ImproveTracing
+      ) {
+        throw new BadDataException(
+          `taskType must be ${CodeFixTaskType.ImproveLogging} or ${CodeFixTaskType.ImproveTracing}.`,
+        );
+      }
+
+      const telemetryServiceId: ObjectID = new ObjectID(
+        telemetryServiceIdParam,
+      );
+
+      /*
+       * Access check under the USER's permissions: the caller must be able
+       * to read the service they are asking the agent to instrument. The
+       * trigger re-reads as root afterwards.
+       */
+      const service: Service | null = await ServiceService.findOneById({
+        id: telemetryServiceId,
+        select: { _id: true },
+        props: props,
+      });
+
+      if (!service) {
+        throw new BadDataException(
+          "Telemetry service not found (or you do not have access to it).",
+        );
+      }
+
+      const run: AIRun =
+        await TelemetryImprovementTaskTrigger.createTelemetryImprovementTask({
+          projectId,
+          telemetryServiceId,
+          taskType: rawTaskType,
+          userId: props.userId!,
+        });
+
+      Response.sendJsonObjectResponse(req, res, {
+        aiRunId: run.id!.toString(),
+      });
+      return;
+    } catch (err) {
+      next(err);
+      return;
+    }
+  },
+);
+
 export default router;