@oneuptime/common 12.0.24 → 12.0.26

package/Server/API/TelemetryAPI.ts

@@ -13,6 +13,12 @@ import CommonAPI from "./CommonAPI";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import TelemetryType from "../../Types/Telemetry/TelemetryType";
 import TelemetryAttributeService from "../Services/TelemetryAttributeService";
+import TelemetrySourceMapService from "../Services/TelemetrySourceMapService";
+import SourceMapResolver from "../Utils/Telemetry/SourceMapResolver";
+import {
+  MinifiedStackFrame,
+  ResolveStackTraceResult,
+} from "../../Types/Telemetry/SourceMap";
 import LogAggregationService, {
   HistogramBucket,
   HistogramRequest,
@@ -36,7 +42,6 @@ import TraceAggregationService, {
   FacetValue as TraceFacetValue,
   MultiFacetRequest as TraceMultiFacetRequest,
   TraceFilters,
-  TraceAttributeFilters,
   TraceAnalyticsChartType,
   TraceAnalyticsRequest,
   TraceAnalyticsTimeseriesRow,
@@ -52,6 +57,7 @@ import ExceptionAggregationService, {
 import MetricAggregationService, {
   FacetValue as MetricFacetValue,
   FacetRequest as MetricFacetRequest,
+  MetricAttributeFilters,
   MetricForTraceItem,
 } from "../Services/MetricAggregationService";
 import ProfileAggregationService, {
@@ -275,6 +281,91 @@ router.post(
   },
 );
 
+/*
+ * Lazily resolves an exception's parsed stack frames against the source
+ * maps uploaded for its (service, release) pair — see the TelemetrySourceMap
+ * model. Guarded by exception read access, not source-map read access, on
+ * purpose: anyone who may see the exception may see the few original source
+ * lines around its crash site (the snippets in the response). Bulk access to
+ * whole maps stays restricted by the model's own column ACL on `content`.
+ * That is a deliberate trade-off, not an oversight: a caller with exception
+ * read access could reconstruct larger stretches of sourcesContent by
+ * probing many line/column pairs across requests, exactly as they could in
+ * Sentry or Elastic. The content column ACL exists to prevent trivial bulk
+ * export, not to be an information-flow boundary against a team member who
+ * is already trusted to read the project's exceptions.
+ *
+ * Tenant safety: source maps are queried by (tenantId from the authorized
+ * request, serviceId from the body). A serviceId belonging to a different
+ * project simply matches no maps — nothing cross-tenant can be read.
+ */
+router.post(
+  "/telemetry/exceptions/resolve-stack-trace",
+  ...requireExceptionReadAccess,
+  async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+    try {
+      const databaseProps: DatabaseCommonInteractionProps =
+        await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+      if (!databaseProps?.tenantId) {
+        return Response.sendErrorResponse(
+          req,
+          res,
+          new BadDataException("Invalid Project ID"),
+        );
+      }
+
+      const body: JSONObject = req.body as JSONObject;
+
+      if (!body["serviceId"] || typeof body["serviceId"] !== "string") {
+        return Response.sendErrorResponse(
+          req,
+          res,
+          new BadDataException("serviceId is required"),
+        );
+      }
+
+      if (
+        !body["serviceVersion"] ||
+        typeof body["serviceVersion"] !== "string"
+      ) {
+        return Response.sendErrorResponse(
+          req,
+          res,
+          new BadDataException("serviceVersion is required"),
+        );
+      }
+
+      if (!Array.isArray(body["frames"])) {
+        return Response.sendErrorResponse(
+          req,
+          res,
+          new BadDataException("frames must be an array of stack frames"),
+        );
+      }
+
+      const frames: Array<MinifiedStackFrame> =
+        SourceMapResolver.sanitizeMinifiedStackFrames(body["frames"]);
+
+      const result: ResolveStackTraceResult =
+        await TelemetrySourceMapService.resolveFramesForService({
+          projectId: databaseProps.tenantId,
+          serviceId: new ObjectID(body["serviceId"] as string),
+          serviceVersion: body["serviceVersion"] as string,
+          frames: frames,
+        });
+
+      return Response.sendJsonObjectResponse(
+        req,
+        res,
+        result as unknown as JSONObject,
+      );
+    } catch (err) {
+      return next(err);
+    }
+  },
+);
+
 /*
  * Security events flatten their whole source payload into `attributes`, so
  * these are what backs the "add an attribute column" picker on the security
@@ -736,6 +827,75 @@ async function resolveResourceScopesFromBody(
   return scopes.length > 0 ? scopes : undefined;
 }
 
+/*
+ * The wire shape of an attribute filter map — the same for logs, traces and
+ * metrics, so it is structurally assignable to each service's own filter
+ * type.
+ */
+type ParsedAttributeFilters = Record<
+  string,
+  string | Array<string> | { _type: string; value?: unknown }
+>;
+
+/*
+ * Parse the `attributes` body field.
+ *
+ * Three shapes are legal: a single value (`= v`), a list of values
+ * (`IN (...)`, what a multi-select dashboard variable resolves to), and a
+ * serialized QueryOperator (`{_type: "Wildcard", value: ["api-*"]}`) for
+ * every other operator the search grammar can produce. Everything else is
+ * dropped, and an array left empty by the string filtering is dropped too so
+ * it cannot narrow to nothing.
+ *
+ * The operator shape used to be dropped here, which is worse than rejecting
+ * it: a wildcard filter arrived as "no filter", so the chart showed the whole
+ * project beside a list narrowed to a handful of spans. `_type` is only
+ * checked for being a string — the compiler in AttributeFilterStatement
+ * answers an unknown operator with a 400.
+ */
+function parseAttributeFilterRecord(
+  raw: unknown,
+): ParsedAttributeFilters | undefined {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return undefined;
+  }
+
+  const filters: ParsedAttributeFilters = {};
+
+  for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {
+    if (typeof value === "string") {
+      filters[key] = value;
+      continue;
+    }
+
+    if (Array.isArray(value)) {
+      const values: Array<string> = (value as Array<unknown>).filter(
+        (v: unknown): v is string => {
+          return typeof v === "string";
+        },
+      );
+      if (values.length > 0) {
+        filters[key] = values;
+      }
+      continue;
+    }
+
+    if (
+      value &&
+      typeof value === "object" &&
+      typeof (value as Record<string, unknown>)["_type"] === "string"
+    ) {
+      filters[key] = value as { _type: string; value?: unknown };
+    }
+  }
+
+  if (Object.keys(filters).length === 0) {
+    return undefined;
+  }
+
+  return filters;
+}
+
 /*
  * Shared body parsing for every trace aggregation endpoint (histogram,
  * facets, analytics). Defensive about shapes: arrays are validated and
@@ -801,42 +961,6 @@ function parseTraceFilterBody(body: JSONObject): TraceFilters {
     return Object.fromEntries(entries);
   };
 
-  /*
-   * Exact attribute predicates accept a single value or a list of values
-   * (`IN (...)`) — a multi-select dashboard variable resolves to the latter.
-   * Non-string array entries are dropped, and an array left empty by that
-   * filtering is dropped entirely so it cannot narrow to nothing.
-   */
-  const attributeFilterRecord: () => TraceAttributeFilters | undefined = ():
-    | TraceAttributeFilters
-    | undefined => {
-    const raw: unknown = body["attributes"];
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-      return undefined;
-    }
-    const filters: TraceAttributeFilters = {};
-    for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {
-      if (typeof value === "string") {
-        filters[key] = value;
-        continue;
-      }
-      if (Array.isArray(value)) {
-        const values: Array<string> = (value as Array<unknown>).filter(
-          (v: unknown): v is string => {
-            return typeof v === "string";
-          },
-        );
-        if (values.length > 0) {
-          filters[key] = values;
-        }
-      }
-    }
-    if (Object.keys(filters).length === 0) {
-      return undefined;
-    }
-    return filters;
-  };
-
   return {
     serviceIds,
     entityKeys: stringArray("entityKeys"),
@@ -883,7 +1007,7 @@ function parseTraceFilterBody(body: JSONObject): TraceFilters {
         : undefined,
     rootOnly:
       body["rootOnly"] === undefined ? undefined : Boolean(body["rootOnly"]),
-    attributes: attributeFilterRecord(),
+    attributes: parseAttributeFilterRecord(body["attributes"]),
     attributeSearches: stringRecord("attributeSearches"),
   };
 }
@@ -1651,6 +1775,9 @@ router.post(
         ? (body["metricNames"] as Array<string>)
         : undefined;
 
+      const attributes: MetricAttributeFilters | undefined =
+        parseAttributeFilterRecord(body["attributes"]);
+
       const facetSearchText: Record<string, string> | undefined = body[
         "facetSearchText"
       ]
@@ -1678,6 +1805,7 @@ router.post(
                   limit,
                   serviceIds,
                   metricNames,
+                  attributes,
                 };
                 const values: Array<MetricFacetValue> =
                   await MetricAggregationService.getFacetValues(request);
@@ -2004,10 +2132,7 @@ function parseErrorPatternFilterBody(
     traceIds: stringArray(body["traceIds"]),
     spanIds: stringArray(body["spanIds"]),
     sessionIds: stringArray(body["sessionIds"]),
-    attributes:
-      body["attributes"] && typeof body["attributes"] === "object"
-        ? (body["attributes"] as Record<string, string | Array<string>>)
-        : undefined,
+    attributes: parseAttributeFilterRecord(body["attributes"]),
   };
 }
 

package/Server/API/UserOnCallLogTimelineAPI.ts

@@ -22,6 +22,13 @@ import ObjectID from "../../Types/ObjectID";
 import UserNotificationStatus from "../../Types/UserNotification/UserNotificationStatus";
 import UserOnCallLogTimeline from "../../Models/DatabaseModels/UserOnCallLogTimeline";
 import Route from "../../Types/API/Route";
+import {
+  OnCallNotificationContext,
+  OnCallNotificationResourceReference,
+  detailsToJSON,
+  getOnCallNotificationContext,
+  getResourceReference,
+} from "../Utils/OnCallNotificationContext";
 
 export default class UserNotificationLogTimelineAPI extends BaseAPI<
   UserOnCallLogTimeline,
@@ -130,22 +137,26 @@ export default class UserNotificationLogTimelineAPI extends BaseAPI<
                 triggeredByIncidentId: true,
                 triggeredByIncident: {
                   title: true,
-                  description: true,
                 },
                 triggeredByAlertId: true,
                 triggeredByAlert: {
                   title: true,
-                  description: true,
                 },
                 triggeredByAlertEpisodeId: true,
                 triggeredByAlertEpisode: {
                   title: true,
-                  description: true,
                 },
                 triggeredByIncidentEpisodeId: true,
                 triggeredByIncidentEpisode: {
                   title: true,
-                  description: true,
+                },
+                /*
+                 * The timestamps below are rendered in the recipient's own
+                 * timezone. Formatting them in the container's zone would tell
+                 * an on-call engineer nothing.
+                 */
+                user: {
+                  timezone: true,
                 },
               },
               props: {
@@ -161,15 +172,28 @@ export default class UserNotificationLogTimelineAPI extends BaseAPI<
             );
           }
 
-          const notificationType: string = timelineItem.triggeredByIncidentId
-            ? "Incident"
-            : timelineItem.triggeredByIncidentEpisodeId
-              ? "Incident Episode"
-              : timelineItem.triggeredByAlertEpisodeId
-                ? "Alert Episode"
-                : "Alert";
+          const reference: OnCallNotificationResourceReference | null =
+            getResourceReference(timelineItem);
+
+          const notificationType: string = reference
+            ? reference.resourceType.toString()
+            : "Alert";
+
+          /*
+           * The context read is what puts severity, state, project, monitors
+           * and the time it was raised on the page. It is best effort on
+           * purpose: a deleted resource, or a resource this notification no
+           * longer points at, must still leave a page the engineer can
+           * acknowledge from.
+           */
+          const context: OnCallNotificationContext | null =
+            await getOnCallNotificationContext({
+              timelineItem: timelineItem,
+              timezone: timelineItem.user?.timezone?.toString(),
+            });
 
           const notificationTitle: string =
+            context?.resourceTitle ||
             timelineItem.triggeredByIncident?.title ||
             timelineItem.triggeredByIncidentEpisode?.title ||
             timelineItem.triggeredByAlertEpisode?.title ||
@@ -194,6 +218,10 @@ export default class UserNotificationLogTimelineAPI extends BaseAPI<
                   .addRoute(new UserOnCallLogTimeline().crudApiPath!)
                   .addRoute("/acknowledge/" + itemId.toString()),
               ).toString(),
+              resourceNumber: context?.resourceNumber || "",
+              resourceTitle: notificationTitle,
+              resourceDescription: context?.resourceDescription || "",
+              details: detailsToJSON(context?.details || []),
             },
           );
         } catch (error) {
@@ -245,6 +273,9 @@ export default class UserNotificationLogTimelineAPI extends BaseAPI<
                 },
                 acknowledgedAt: true,
                 isAcknowledged: true,
+                user: {
+                  timezone: true,
+                },
               },
               props: {
                 isRoot: true,
@@ -262,59 +293,38 @@ export default class UserNotificationLogTimelineAPI extends BaseAPI<
           const host: Hostname = await DatabaseConfig.getHost();
           const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
 
-          // Determine the resource type and ID for routing
-          type ResourceInfo = {
-            type: string;
-            path: string;
-            id: ObjectID;
-            title: string;
-          };
-
-          const getResourceInfo: () => ResourceInfo = (): ResourceInfo => {
-            if (timelineItem.triggeredByIncidentId) {
-              return {
-                type: "Incident",
-                path: "incidents",
-                id: timelineItem.triggeredByIncidentId,
-                title: timelineItem.triggeredByIncident?.title || "",
-              };
-            }
-            if (timelineItem.triggeredByIncidentEpisodeId) {
-              return {
-                type: "Incident Episode",
-                path: "incidents/episodes",
-                id: timelineItem.triggeredByIncidentEpisodeId,
-                title: timelineItem.triggeredByIncidentEpisode?.title || "",
-              };
-            }
-            if (timelineItem.triggeredByAlertEpisodeId) {
-              return {
-                type: "Alert Episode",
-                path: "alerts/episodes",
-                id: timelineItem.triggeredByAlertEpisodeId,
-                title: timelineItem.triggeredByAlertEpisode?.title || "",
-              };
-            }
-            if (timelineItem.triggeredByAlertId) {
-              return {
-                type: "Alert",
-                path: "alerts",
-                id: timelineItem.triggeredByAlertId,
-                title: timelineItem.triggeredByAlert?.title || "",
-              };
-            }
-            return { type: "", path: "", id: new ObjectID(""), title: "" };
-          };
-
-          const resourceInfo: ResourceInfo = getResourceInfo();
+          // Determine the resource type and ID for routing.
+          const reference: OnCallNotificationResourceReference | null =
+            getResourceReference(timelineItem);
+
+          const fallbackTitle: string =
+            timelineItem.triggeredByIncident?.title ||
+            timelineItem.triggeredByIncidentEpisode?.title ||
+            timelineItem.triggeredByAlertEpisode?.title ||
+            timelineItem.triggeredByAlert?.title ||
+            "";
 
           if (timelineItem.isAcknowledged) {
             // already acknowledged. Then show already acknowledged page with view details button.
 
+            /*
+             * Same context the acknowledge page shows. Someone who follows the
+             * link twice - or whose colleague got there first - still needs to
+             * know what the page they are looking at is about.
+             */
+            const context: OnCallNotificationContext | null =
+              await getOnCallNotificationContext({
+                timelineItem: timelineItem,
+                timezone: timelineItem.user?.timezone?.toString(),
+              });
+
+            const acknowledgedTitle: string =
+              context?.resourceTitle || fallbackTitle;
+
             const viewDetailsRoute: Route = new Route(
               DashboardRoute.toString(),
             ).addRoute(
-              `/${timelineItem.projectId?.toString()}/${resourceInfo.path}/${resourceInfo.id.toString()}`,
+              `/${timelineItem.projectId?.toString()}/${reference?.dashboardPath || ""}/${reference?.resourceId.toString() || ""}`,
             );
 
             const viewDetailsUrl: URL = new URL(
@@ -328,10 +338,14 @@ export default class UserNotificationLogTimelineAPI extends BaseAPI<
               res,
               "/usr/src/Common/Server/Views/ViewMessage.ejs",
               {
-                title: `Notification Already Acknowledged - ${resourceInfo.title}`,
+                title: `Notification Already Acknowledged - ${acknowledgedTitle}`,
                 message: `This notification has already been acknowledged.`,
-                viewDetailsText: `View ${resourceInfo.type}`,
+                viewDetailsText: `View ${reference?.resourceType.toString() || ""}`,
                 viewDetailsUrl: viewDetailsUrl.toString(),
+                resourceNumber: context?.resourceNumber || "",
+                resourceTitle: acknowledgedTitle,
+                resourceDescription: context?.resourceDescription || "",
+                details: detailsToJSON(context?.details || []),
               },
             );
           }
@@ -350,11 +364,11 @@ export default class UserNotificationLogTimelineAPI extends BaseAPI<
           });
 
           // redirect to dashboard to the resource page.
-          if (resourceInfo.path) {
+          if (reference) {
             const resourceRoute: Route = new Route(
               DashboardRoute.toString(),
             ).addRoute(
-              `/${timelineItem.projectId?.toString()}/${resourceInfo.path}/${resourceInfo.id.toString()}`,
+              `/${timelineItem.projectId?.toString()}/${reference.dashboardPath}/${reference.resourceId.toString()}`,
             );
 
             return Response.redirect(

package/Server/API/UserTotpAuthAPI.ts

@@ -13,9 +13,13 @@ import BaseAPI from "./BaseAPI";
 import UserTotpAuth from "../../Models/DatabaseModels/UserTotpAuth";
 import BadDataException from "../../Types/Exception/BadDataException";
 import TotpAuth from "../Utils/TotpAuth";
+import TwoFactorBackupCode from "../Utils/TwoFactorBackupCode";
 import Response from "../Utils/Response";
 import User from "../../Models/DatabaseModels/User";
 import UserService from "../Services/UserService";
+import UserTwoFactorBackupCodeService from "../Services/UserTwoFactorBackupCodeService";
+import logger from "../Utils/Logger";
+import TwoFactorBackupCodeNotification from "../Utils/TwoFactorBackupCodeNotification";
 
 export default class UserTotpAuthAPI extends BaseAPI<
   UserTotpAuth,
@@ -97,7 +101,69 @@ export default class UserTotpAuthAPI extends BaseAPI<
             },
           });
 
-          return Response.sendEmptySuccessResponse(req, res);
+          /*
+           * The account now has a second factor, which means it now has
+           * something to lose. Mint the recovery codes here rather than
+           * leaving them to a button the user has to go and find: a set that
+           * is never generated is the same as no recovery route at all, which
+           * is the state this endpoint used to leave every account in.
+           *
+           * `generateForUserIfNone` and not a regeneration -- adding a SECOND
+           * authenticator app must not void the codes the user printed when
+           * they added the first. It returns null in that case and the
+           * response simply carries no codes.
+           *
+           * THE RESPONSE IS THE ONLY COPY. Only keyed digests are stored, so
+           * whatever is returned here is the one and only time these strings
+           * exist; the profile page is expected to raise the same
+           * acknowledge-before-closing modal it raises for a manual
+           * regeneration. That is also why nothing is minted anywhere the user
+           * is not looking at a screen that can show it.
+           *
+           * A failure to mint must not fail the validation. The factor IS
+           * verified by this point -- the row is written -- so throwing here
+           * would tell the user their authenticator did not work when it did,
+           * and send them round the enrolment loop again. The profile card
+           * already warns an account holding no codes, so the fallback is a
+           * state the product knows how to talk about.
+           */
+          let backupCodes: Array<string> | null = null;
+
+          try {
+            backupCodes =
+              await UserTwoFactorBackupCodeService.generateForUserIfNone({
+                userId: userTotpAuth.userId!,
+              });
+          } catch (backupCodeError) {
+            logger.error(backupCodeError);
+          }
+
+          /*
+           * Tell the account holder, at their address rather than in this
+           * browser. Ten sign-in credentials have just come into existence on
+           * this account, and this route is authenticated by a session alone
+           * -- so a stolen session is enough to create them. The mail does not
+           * prevent that; it makes it visible to the person it was done to.
+           */
+          if (backupCodes && backupCodes.length > 0) {
+            TwoFactorBackupCodeNotification.notifyCodesCreated({
+              userId: userTotpAuth.userId!,
+              codeCount: backupCodes.length,
+            });
+          }
+
+          return Response.sendJsonObjectResponse(req, res, {
+            /*
+             * Hyphenated for the page to render as-is, exactly as the
+             * regenerate route does. The verify route normalizes whatever
+             * comes back.
+             */
+            backupCodes: backupCodes
+              ? backupCodes.map((code: string) => {
+                  return TwoFactorBackupCode.formatForDisplay(code);
+                })
+              : [],
+          });
         } catch (err) {
           next(err);
         }

package/Server/API/UserWebAuthnAPI.ts

@@ -16,6 +16,10 @@ import Response from "../Utils/Response";
 import { JSONObject } from "../../Types/JSON";
 import CommonAPI from "./CommonAPI";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import UserTwoFactorBackupCodeService from "../Services/UserTwoFactorBackupCodeService";
+import TwoFactorBackupCode from "../Utils/TwoFactorBackupCode";
+import logger from "../Utils/Logger";
+import TwoFactorBackupCodeNotification from "../Utils/TwoFactorBackupCodeNotification";
 
 export default class UserWebAuthnAPI extends BaseAPI<
   UserWebAuthn,
@@ -63,7 +67,46 @@ export default class UserWebAuthnAPI extends BaseAPI<
             props: databaseProps,
           });
 
-          return Response.sendEmptySuccessResponse(req, res);
+          /*
+           * A security key is a second factor that can be left in a taxi, so
+           * registering one is a moment that needs a recovery route behind it.
+           * Minted here for the same reason -- and with the same
+           * only-if-there-are-none rule -- as on the TOTP validate route; see
+           * the note there. A key added ALONGSIDE an authenticator app finds
+           * codes already present and changes nothing.
+           *
+           * Never fatal to the registration: the credential is already saved
+           * at this point, so an error here would report a failure for work
+           * that succeeded.
+           */
+          let backupCodes: Array<string> | null = null;
+
+          if (databaseProps.userId) {
+            try {
+              backupCodes =
+                await UserTwoFactorBackupCodeService.generateForUserIfNone({
+                  userId: databaseProps.userId,
+                });
+            } catch (backupCodeError) {
+              logger.error(backupCodeError);
+            }
+          }
+
+          /* See the note on the TOTP validate route. */
+          if (backupCodes && backupCodes.length > 0 && databaseProps.userId) {
+            TwoFactorBackupCodeNotification.notifyCodesCreated({
+              userId: databaseProps.userId,
+              codeCount: backupCodes.length,
+            });
+          }
+
+          return Response.sendJsonObjectResponse(req, res, {
+            backupCodes: backupCodes
+              ? backupCodes.map((code: string) => {
+                  return TwoFactorBackupCode.formatForDisplay(code);
+                })
+              : [],
+          });
         } catch (err) {
           next(err);
         }