@oneuptime/common 10.0.46 → 10.0.50

package/Models/AnalyticsModels/AnalyticsBaseModel/CommonModel.ts

@@ -69,7 +69,11 @@ export default class CommonModel {
         value = new ObjectID(value as string | JSONObject);
       }
 
-      if (column.type === TableColumnType.Date && typeof value === "string") {
+      if (
+        (column.type === TableColumnType.Date ||
+          column.type === TableColumnType.DateTime64) &&
+        typeof value === "string"
+      ) {
         value = OneUptimeDate.fromString(value);
       }
 

package/Server/Services/DashboardService.ts

@@ -13,6 +13,11 @@ import Model from "../../Models/DatabaseModels/Dashboard";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import { PlanType } from "../../Types/Billing/SubscriptionPlan";
 import DashboardViewConfigUtil from "../../Utils/Dashboard/DashboardViewConfig";
+import {
+  DashboardTemplateType,
+  getTemplateConfig,
+} from "../../Types/Dashboard/DashboardTemplates";
+import DashboardViewConfig from "../../Types/Dashboard/DashboardViewConfig";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import ObjectID from "../../Types/ObjectID";
 import { JSONObject } from "../../Types/JSON";
@@ -55,6 +60,27 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    // Check if a template type was provided via miscDataProps
+    const templateType: string | undefined = createBy.miscDataProps?.[
+      "dashboardTemplateType"
+    ] as string | undefined;
+
+    if (
+      templateType &&
+      templateType !== DashboardTemplateType.Blank &&
+      Object.values(DashboardTemplateType).includes(
+        templateType as DashboardTemplateType,
+      )
+    ) {
+      const templateConfig: DashboardViewConfig | null = getTemplateConfig(
+        templateType as DashboardTemplateType,
+      );
+
+      if (templateConfig) {
+        createBy.data.dashboardViewConfig = templateConfig;
+      }
+    }
+
     // use default empty config only if no template config was provided.
     if (
       !createBy.data.dashboardViewConfig ||

package/Tests/Models/AnalyticsModels/Log.test.ts

@@ -0,0 +1,15 @@
+import Log from "../../../Models/AnalyticsModels/Log";
+
+describe("Analytics Log model", () => {
+  test("should deserialize ClickHouse DateTime64 values as Date objects", () => {
+    const log: Log = Log.fromJSON(
+      {
+        time: "2026-04-01 14:45:31.414000000",
+      },
+      Log,
+    ) as Log;
+
+    expect(log.time).toBeInstanceOf(Date);
+    expect(log.time?.toISOString()).toBe("2026-04-01T14:45:31.414Z");
+  });
+});

package/Tests/Types/Date.test.ts

@@ -86,4 +86,10 @@ describe("class OneUptimeDate", () => {
       OneUptimeDate.getSomeSecondsAfter(new PositiveNumber(4)).getSeconds(),
     ).toEqual(moment().add(4, "seconds").toDate().getSeconds());
   });
+
+  test("OneUptimeDate.fromString should parse ClickHouse timestamps as UTC", () => {
+    expect(
+      OneUptimeDate.fromString("2026-04-01 14:45:31.414000000").toISOString(),
+    ).toBe("2026-04-01T14:45:31.414Z");
+  });
 });

package/Tests/UI/Components/XAxis.test.ts

@@ -0,0 +1,30 @@
+// eslint-disable-next-line no-undef
+process.env.TZ = "Europe/London";
+
+import XAxisUtil from "../../../UI/Components/Charts/Utils/XAxis";
+
+describe("XAxisUtil", () => {
+  test("formats past-day chart labels in local BST time instead of UTC", () => {
+    const formatter: (value: Date) => string = XAxisUtil.getFormatter({
+      xAxisMin: new Date("2026-04-06T14:00:00.000Z"),
+      xAxisMax: new Date("2026-04-07T14:00:00.000Z"),
+    });
+
+    expect(formatter(new Date("2026-04-07T07:30:00.000Z"))).toBe(
+      "07 Apr, 08:00",
+    );
+  });
+
+  test("does not mutate the original date while rounding local labels", () => {
+    const formatter: (value: Date) => string = XAxisUtil.getFormatter({
+      xAxisMin: new Date("2026-04-06T14:00:00.000Z"),
+      xAxisMax: new Date("2026-04-07T14:00:00.000Z"),
+    });
+
+    const originalDate: Date = new Date("2026-04-07T07:30:45.000Z");
+
+    formatter(originalDate);
+
+    expect(originalDate.toISOString()).toBe("2026-04-07T07:30:45.000Z");
+  });
+});

package/Types/Date.ts

@@ -12,6 +12,41 @@ export const Moment: typeof moment = moment;
 export default class OneUptimeDate {
   // get date time from unix timestamp
 
+  private static padDatePart(value: number): string {
+    return value.toString().padStart(2, "0");
+  }
+
+  private static isUtcDateTimeString(value: string): boolean {
+    const utcDateTimePattern: RegExp =
+      /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d{1,9})?$/;
+
+    return utcDateTimePattern.test(value.trim());
+  }
+
+  private static normalizeUtcDateTimeString(value: string): string {
+    const trimmedValue: string = value.trim();
+    const [datePart, timePart] = trimmedValue.split(" ");
+
+    if (!datePart || !timePart) {
+      return trimmedValue;
+    }
+
+    const [baseTime, fractionalPart] = timePart.split(".");
+
+    if (!fractionalPart) {
+      return `${datePart}T${baseTime}Z`;
+    }
+
+    const milliseconds: string = fractionalPart.slice(0, 3).padEnd(3, "0");
+    return `${datePart}T${baseTime}.${milliseconds}Z`;
+  }
+
+  private static getLocalShortMonthName(date: Date): string {
+    return date.toLocaleString("default", {
+      month: "short",
+    });
+  }
+
   public static getSchema(): ZodSchema {
     return Zod.object({
       _type: Zod.literal(ObjectType.DateTime),
@@ -106,8 +141,63 @@ export default class OneUptimeDate {
   }
 
   public static getLocalHourAndMinuteFromDate(date: Date | string): string {
+    return this.getLocalTimeString(date);
+  }
+
+  public static getLocalShortMonthNameFromDate(date: Date | string): string {
     date = this.fromString(date);
-    return moment(date).format("HH:mm");
+    return this.getLocalShortMonthName(date);
+  }
+
+  public static getLocalTimeString(
+    date: Date | string,
+    options?: {
+      includeMinutes?: boolean;
+      includeSeconds?: boolean;
+    },
+  ): string {
+    date = this.fromString(date);
+
+    const includeMinutes: boolean = options?.includeMinutes ?? true;
+    const includeSeconds: boolean = options?.includeSeconds ?? false;
+    const hours: string = this.padDatePart(date.getHours());
+
+    if (!includeMinutes) {
+      return hours;
+    }
+
+    const minutes: string = this.padDatePart(date.getMinutes());
+
+    if (!includeSeconds) {
+      return `${hours}:${minutes}`;
+    }
+
+    const seconds: string = this.padDatePart(date.getSeconds());
+    return `${hours}:${minutes}:${seconds}`;
+  }
+
+  public static getDateAsLocalDayMonthString(date: Date | string): string {
+    date = this.fromString(date);
+
+    const day: string = this.padDatePart(date.getDate());
+    const month: string = this.getLocalShortMonthName(date);
+
+    return `${day} ${month}`;
+  }
+
+  public static getDateAsLocalDayMonthHourString(date: Date | string): string {
+    date = this.fromString(date);
+
+    return `${this.getDateAsLocalDayMonthString(date)}, ${this.getLocalTimeString(date, { includeMinutes: false })}:00`;
+  }
+
+  public static getDateAsLocalMonthYearString(date: Date | string): string {
+    date = this.fromString(date);
+
+    const month: string = this.getLocalShortMonthName(date);
+    const year: string = date.getFullYear().toString();
+
+    return `${month} ${year}`;
   }
 
   public static getMillisecondsBetweenTwoUnixNanoDates(
@@ -1442,7 +1532,15 @@ export default class OneUptimeDate {
     }
 
     if (typeof date === "string") {
-      return moment(date).toDate();
+      const trimmedDate: string = date.trim();
+
+      if (this.isUtcDateTimeString(trimmedDate)) {
+        return moment
+          .utc(this.normalizeUtcDateTimeString(trimmedDate))
+          .toDate();
+      }
+
+      return moment(trimmedDate).toDate();
     }
 
     if (

package/UI/Components/Charts/Utils/XAxis.ts

@@ -4,6 +4,10 @@ import XAxisMaxMin from "../Types/XAxis/XAxisMaxMin";
 import XAxisPrecision from "../Types/XAxis/XAxisPrecision";
 
 export default class XAxisUtil {
+  private static cloneDate(value: Date): Date {
+    return new Date(value.getTime());
+  }
+
   public static getPrecision(data: {
     xAxisMin: XAxisMaxMin;
     xAxisMax: XAxisMaxMin;
@@ -203,211 +207,196 @@ export default class XAxisUtil {
     switch (precision) {
       case XAxisPrecision.EVERY_SECOND:
         return (value: Date) => {
-          // round down to nearest second
-          return value.toISOString().substring(11, 19);
+          return OneUptimeDate.getLocalTimeString(value, {
+            includeSeconds: true,
+          });
         };
       case XAxisPrecision.EVERY_FIVE_SECONDS:
         // round down to nearest 5 seconds
         return (value: Date) => {
-          const seconds: number = value.getSeconds();
+          const roundedValue: Date = this.cloneDate(value);
+          const seconds: number = roundedValue.getSeconds();
           const roundedSeconds: number = Math.floor(seconds / 5) * 5;
-          value.setSeconds(roundedSeconds);
-          return value.toISOString().substring(11, 19);
+          roundedValue.setSeconds(roundedSeconds, 0);
+
+          return OneUptimeDate.getLocalTimeString(roundedValue, {
+            includeSeconds: true,
+          });
         };
       case XAxisPrecision.EVERY_TEN_SECONDS:
         // round down to nearest 10 seconds
         return (value: Date) => {
-          const seconds: number = value.getSeconds();
+          const roundedValue: Date = this.cloneDate(value);
+          const seconds: number = roundedValue.getSeconds();
           const roundedSeconds: number = Math.floor(seconds / 10) * 10;
-          value.setSeconds(roundedSeconds);
-          return value.toISOString().substring(11, 19);
+          roundedValue.setSeconds(roundedSeconds, 0);
+
+          return OneUptimeDate.getLocalTimeString(roundedValue, {
+            includeSeconds: true,
+          });
         };
       case XAxisPrecision.EVERY_THIRTY_SECONDS:
         // round down to nearest 30 seconds
         return (value: Date) => {
-          const seconds: number = value.getSeconds();
+          const roundedValue: Date = this.cloneDate(value);
+          const seconds: number = roundedValue.getSeconds();
           const roundedSeconds: number = Math.floor(seconds / 30) * 30;
-          value.setSeconds(roundedSeconds);
-          return value.toISOString().substring(11, 19);
+          roundedValue.setSeconds(roundedSeconds, 0);
+
+          return OneUptimeDate.getLocalTimeString(roundedValue, {
+            includeSeconds: true,
+          });
         };
       case XAxisPrecision.EVERY_MINUTE:
         // round down to nearest minute
         return (value: Date) => {
-          return value.toISOString().substring(11, 16);
+          return OneUptimeDate.getLocalTimeString(value);
         };
       case XAxisPrecision.EVERY_FIVE_MINUTES:
         // round down to nearest 5 minutes
         return (value: Date) => {
-          const minutes: number = value.getMinutes();
+          const roundedValue: Date = this.cloneDate(value);
+          const minutes: number = roundedValue.getMinutes();
           const roundedMinutes: number = Math.floor(minutes / 5) * 5;
-          value.setMinutes(roundedMinutes);
-          return value.toISOString().substring(11, 16);
+          roundedValue.setMinutes(roundedMinutes, 0, 0);
+
+          return OneUptimeDate.getLocalTimeString(roundedValue);
         };
       case XAxisPrecision.EVERY_TEN_MINUTES:
         // round down to nearest 10 minutes
         return (value: Date) => {
-          const minutes: number = value.getMinutes();
+          const roundedValue: Date = this.cloneDate(value);
+          const minutes: number = roundedValue.getMinutes();
           const roundedMinutes: number = Math.floor(minutes / 10) * 10;
-          value.setMinutes(roundedMinutes);
-          return value.toISOString().substring(11, 16);
+          roundedValue.setMinutes(roundedMinutes, 0, 0);
+
+          return OneUptimeDate.getLocalTimeString(roundedValue);
         };
       case XAxisPrecision.EVERY_THIRTY_MINUTES:
         // round down to nearest 30 minutes
         return (value: Date) => {
-          const minutes: number = value.getMinutes();
+          const roundedValue: Date = this.cloneDate(value);
+          const minutes: number = roundedValue.getMinutes();
           const roundedMinutes: number = Math.floor(minutes / 30) * 30;
-          value.setMinutes(roundedMinutes);
-          return value.toISOString().substring(11, 16);
+          roundedValue.setMinutes(roundedMinutes, 0, 0);
+
+          return OneUptimeDate.getLocalTimeString(roundedValue);
         };
       case XAxisPrecision.EVERY_HOUR:
         return (value: Date) => {
-          return value.toISOString().substring(11, 13);
+          return OneUptimeDate.getLocalTimeString(value, {
+            includeMinutes: false,
+          });
         }; // HH:00
       case XAxisPrecision.EVERY_TWO_HOURS:
         return (value: Date) => {
-          const hours: number = value.getHours();
+          const roundedValue: Date = this.cloneDate(value);
+          const hours: number = roundedValue.getHours();
           const roundedHours: number = Math.floor(hours / 2) * 2;
-          value.setHours(roundedHours);
+          roundedValue.setHours(roundedHours, 0, 0, 0);
 
-          const dateString: string = value.toISOString();
-          const day: string = dateString.substring(8, 10);
-          const month: string = value.toLocaleString("default", {
-            month: "short",
-          });
-          return `${day} ${month}, ${value.toISOString().substring(11, 13)}:00`;
+          return OneUptimeDate.getDateAsLocalDayMonthHourString(roundedValue);
         };
       case XAxisPrecision.EVERY_THREE_HOURS:
         // round down to nearest 3 hours
         return (value: Date) => {
-          const hours: number = value.getHours();
+          const roundedValue: Date = this.cloneDate(value);
+          const hours: number = roundedValue.getHours();
           const roundedHours: number = Math.floor(hours / 3) * 3;
-          value.setHours(roundedHours);
+          roundedValue.setHours(roundedHours, 0, 0, 0);
 
-          const dateString: string = value.toISOString();
-          const day: string = dateString.substring(8, 10);
-          const month: string = value.toLocaleString("default", {
-            month: "short",
-          });
-          return `${day} ${month}, ${value.toISOString().substring(11, 13)}:00`;
+          return OneUptimeDate.getDateAsLocalDayMonthHourString(roundedValue);
         };
       case XAxisPrecision.EVERY_SIX_HOURS:
         // round down to nearest 6 hours // HH:00 DD MMM
         return (value: Date) => {
-          const hours: number = value.getHours();
+          const roundedValue: Date = this.cloneDate(value);
+          const hours: number = roundedValue.getHours();
           const roundedHours: number = Math.floor(hours / 6) * 6;
-          value.setHours(roundedHours);
+          roundedValue.setHours(roundedHours, 0, 0, 0);
 
-          const dateString: string = value.toISOString();
-          const day: string = dateString.substring(8, 10);
-          const month: string = value.toLocaleString("default", {
-            month: "short",
-          });
-          return `${day} ${month}, ${value.toISOString().substring(11, 13)}:00`;
+          return OneUptimeDate.getDateAsLocalDayMonthHourString(roundedValue);
         };
       case XAxisPrecision.EVERY_TWELVE_HOURS:
         // round down to nearest 12 hours  // DD MMM, HH:00
         return (value: Date) => {
-          const hours: number = value.getHours();
+          const roundedValue: Date = this.cloneDate(value);
+          const hours: number = roundedValue.getHours();
           const roundedHours: number = Math.floor(hours / 12) * 12;
-          value.setHours(roundedHours);
+          roundedValue.setHours(roundedHours, 0, 0, 0);
 
-          const dateString: string = value.toISOString();
-          const day: string = dateString.substring(8, 10);
-          const month: string = value.toLocaleString("default", {
-            month: "short",
-          });
-          const hour: string = dateString.substring(11, 13);
-          return `${day} ${month}, ${hour}:00`;
+          return OneUptimeDate.getDateAsLocalDayMonthHourString(roundedValue);
         };
       case XAxisPrecision.EVERY_DAY:
         // round down to nearest day
         return (value: Date) => {
-          const dateString: string = value.toISOString();
-          const day: string = dateString.substring(8, 10);
-          const month: string = value.toLocaleString("default", {
-            month: "short",
-          });
-          return `${day} ${month}`;
+          return OneUptimeDate.getDateAsLocalDayMonthString(value);
         };
       case XAxisPrecision.EVERY_TWO_DAYS:
         // round down to nearest 2 days
         return (value: Date) => {
-          const days: number = value.getDate();
+          const roundedValue: Date = this.cloneDate(value);
+          const days: number = roundedValue.getDate();
           const roundedDays: number = Math.floor(days / 2) * 2;
-          value.setDate(roundedDays);
-          const dateString: string = value.toISOString();
-          const day: string = dateString.substring(8, 10);
-          const month: string = value.toLocaleString("default", {
-            month: "short",
-          });
-          return `${day} ${month}`;
+          roundedValue.setDate(roundedDays);
+
+          return OneUptimeDate.getDateAsLocalDayMonthString(roundedValue);
         };
       case XAxisPrecision.EVERY_WEEK:
         // round down to nearest week
         return (value: Date) => {
           const day: string = value.getDate().toString();
-          const month: string = value.toLocaleString("default", {
-            month: "short",
-          });
+          const month: string =
+            OneUptimeDate.getLocalShortMonthNameFromDate(value);
           return `${day} ${month}`;
         };
       case XAxisPrecision.EVERY_TWO_WEEKS:
         // round down to nearest 2 weeks. // DD MMM
         return (value: Date) => {
-          const days: number = value.getDate();
+          const roundedValue: Date = this.cloneDate(value);
+          const days: number = roundedValue.getDate();
           const roundedDays: number = Math.floor(days / 2) * 2;
-          value.setDate(roundedDays);
-          const day: string = value.getDate().toString();
-          const month: string = value.toLocaleString("default", {
-            month: "short",
-          });
+          roundedValue.setDate(roundedDays);
+          const day: string = roundedValue.getDate().toString();
+          const month: string =
+            OneUptimeDate.getLocalShortMonthNameFromDate(roundedValue);
           return `${day} ${month}`;
         };
       case XAxisPrecision.EVERY_MONTH:
         // round down to nearest month // MM YYYY
         return (value: Date) => {
-          const month: string = value.toLocaleString("default", {
-            month: "short",
-          });
-          const year: string = value.getFullYear().toString();
-          return `${month} ${year}`;
+          return OneUptimeDate.getDateAsLocalMonthYearString(value);
         };
 
       case XAxisPrecision.EVERY_TWO_MONTHS:
         // round down to nearest 2 months // MM YYYY
         return (value: Date) => {
-          const months: number = value.getMonth();
+          const roundedValue: Date = this.cloneDate(value);
+          const months: number = roundedValue.getMonth();
           const roundedMonths: number = Math.floor(months / 2) * 2;
-          value.setMonth(roundedMonths);
-          const month: string = value.toLocaleString("default", {
-            month: "short",
-          });
-          const year: string = value.getFullYear().toString();
-          return `${month} ${year}`;
+          roundedValue.setMonth(roundedMonths);
+
+          return OneUptimeDate.getDateAsLocalMonthYearString(roundedValue);
         };
       case XAxisPrecision.EVERY_THREE_MONTHS:
         // round down to nearest 3 months // MM YYYY
         return (value: Date) => {
-          const months: number = value.getMonth();
+          const roundedValue: Date = this.cloneDate(value);
+          const months: number = roundedValue.getMonth();
           const roundedMonths: number = Math.floor(months / 3) * 3;
-          value.setMonth(roundedMonths);
-          const month: string = value.toLocaleString("default", {
-            month: "short",
-          });
-          const year: string = value.getFullYear().toString();
-          return `${month} ${year}`;
+          roundedValue.setMonth(roundedMonths);
+
+          return OneUptimeDate.getDateAsLocalMonthYearString(roundedValue);
         };
       case XAxisPrecision.EVERY_SIX_MONTHS:
         // round down to nearest 6 months // MM YYYY
         return (value: Date) => {
-          const months: number = value.getMonth();
+          const roundedValue: Date = this.cloneDate(value);
+          const months: number = roundedValue.getMonth();
           const roundedMonths: number = Math.floor(months / 6) * 6;
-          value.setMonth(roundedMonths);
-          const month: string = value.toLocaleString("default", {
-            month: "short",
-          });
-          const year: string = value.getFullYear().toString();
-          return `${month} ${year}`;
+          roundedValue.setMonth(roundedMonths);
+
+          return OneUptimeDate.getDateAsLocalMonthYearString(roundedValue);
         };
       case XAxisPrecision.EVERY_YEAR:
         // round down to nearest year // YYYY

package/UI/Components/LogsViewer/LogsViewer.tsx

@@ -58,6 +58,7 @@ import RangeStartAndEndDateTime from "../../../Types/Time/RangeStartAndEndDateTi
 import TimeRange from "../../../Types/Time/TimeRange";
 import { exportLogs, LogExportFormat } from "../../Utils/LogExport";
 import ObjectID from "../../../Types/ObjectID";
+import OneUptimeDate from "../../../Types/Date";
 
 export interface ComponentProps {
   logs: Array<Log>;
@@ -279,9 +280,11 @@ const LogsViewer: FunctionComponent<ComponentProps> = (
     cloned.sort((a: Log, b: Log) => {
       if (sortField === "time") {
         const aTime: number =
-          Number(a.timeUnixNano) || (a.time ? new Date(a.time).getTime() : 0);
+          Number(a.timeUnixNano) ||
+          (a.time ? OneUptimeDate.fromString(a.time).getTime() : 0);
         const bTime: number =
-          Number(b.timeUnixNano) || (b.time ? new Date(b.time).getTime() : 0);
+          Number(b.timeUnixNano) ||
+          (b.time ? OneUptimeDate.fromString(b.time).getTime() : 0);
 
         if (aTime === bTime) {
           return 0;

package/UI/Components/LogsViewer/components/HistogramTooltip.tsx

@@ -1,4 +1,5 @@
 import React, { FunctionComponent, ReactElement } from "react";
+import OneUptimeDate from "../../../../Types/Date";
 import { getSeverityColor } from "./severityColors";
 
 export interface TooltipEntry {
@@ -21,7 +22,7 @@ function formatTooltipTime(label: string | undefined): string {
     return "";
   }
 
-  const date: Date = new Date(label);
+  const date: Date = OneUptimeDate.fromString(label);
 
   if (isNaN(date.getTime())) {
     return label;

package/UI/Components/LogsViewer/components/LogDetailsPanel.tsx

@@ -285,7 +285,7 @@ const LogDetailsPanel: FunctionComponent<LogDetailsPanelProps> = (
         <span className="flex-none whitespace-nowrap font-mono text-[11px] text-gray-400">
           {ctxLog.time
             ? OneUptimeDate.getDateAsUserFriendlyFormattedString(
-                new Date(ctxLog.time),
+                OneUptimeDate.fromString(ctxLog.time),
               )
             : "-"}
         </span>

package/UI/Components/LogsViewer/components/LogsAnalyticsView.tsx

@@ -29,6 +29,7 @@ import { JSONObject } from "../../../../Types/JSON";
 import { APP_API_URL } from "../../../Config";
 import ModelAPI from "../../../Utils/ModelAPI/ModelAPI";
 import ComponentLoader from "../../ComponentLoader/ComponentLoader";
+import OneUptimeDate from "../../../../Types/Date";
 
 type AnalyticsChartType = "timeseries" | "toplist" | "table";
 type AnalyticsAggregation = "count" | "unique";
@@ -124,7 +125,7 @@ function pivotTimeseriesData(rows: Array<AnalyticsTimeseriesRow>): {
 }
 
 function formatTickTime(time: string): string {
-  const date: Date = new Date(time);
+  const date: Date = OneUptimeDate.fromString(time);
 
   if (isNaN(date.getTime())) {
     return time;
@@ -230,7 +231,7 @@ const AnalyticsTooltip: FunctionComponent<AnalyticsTooltipProps> = (
       return "";
     }
 
-    const date: Date = new Date(label);
+    const date: Date = OneUptimeDate.fromString(label);
 
     if (isNaN(date.getTime())) {
       return label;

package/UI/Components/LogsViewer/components/LogsHistogram.tsx

@@ -23,6 +23,7 @@ import {
 } from "./severityColors";
 import HistogramTooltip from "./HistogramTooltip";
 import ComponentLoader from "../../ComponentLoader/ComponentLoader";
+import OneUptimeDate from "../../../../Types/Date";
 
 export interface LogsHistogramProps {
   buckets: Array<HistogramBucket>;
@@ -54,7 +55,7 @@ function pivotBuckets(buckets: Array<HistogramBucket>): Array<PivotedRow> {
 }
 
 function formatTickTime(time: string): string {
-  const date: Date = new Date(time);
+  const date: Date = OneUptimeDate.fromString(time);
 
   if (isNaN(date.getTime())) {
     return time;
@@ -138,8 +139,8 @@ const LogsHistogram: FunctionComponent<LogsHistogramProps> = (
 
     isSelecting.current = false;
 
-    const start: Date = new Date(selectionStart);
-    const end: Date = new Date(selectionEnd);
+    const start: Date = OneUptimeDate.fromString(selectionStart);
+    const end: Date = OneUptimeDate.fromString(selectionEnd);
 
     if (isNaN(start.getTime()) || isNaN(end.getTime())) {
       setSelectionStart(null);

package/build/dist/Models/AnalyticsModels/AnalyticsBaseModel/CommonModel.js

@@ -17,7 +17,9 @@ export default class CommonModel {
                 (typeof value === "string" || typeof value === "object")) {
                 value = new ObjectID(value);
             }
-            if (column.type === TableColumnType.Date && typeof value === "string") {
+            if ((column.type === TableColumnType.Date ||
+                column.type === TableColumnType.DateTime64) &&
+                typeof value === "string") {
                 value = OneUptimeDate.fromString(value);
             }
             if (column.type === TableColumnType.JSON && typeof value === "string") {