@oneuptime/common 9.2.5 → 9.2.8

package/Server/Infrastructure/Queue.ts

@@ -1,7 +1,7 @@
 import { ClusterKey } from "../EnvironmentConfig";
 import Dictionary from "../../Types/Dictionary";
 import { JSONObject } from "../../Types/JSON";
-import { Queue as BullQueue, Job, JobsOptions } from "bullmq";
+import { Queue as BullQueue, Job, JobsOptions, RepeatableJob } from "bullmq";
 import { ExpressAdapter } from "@bull-board/express";
 import { createBullBoard } from "@bull-board/api";
 import { BullMQAdapter } from "@bull-board/api/bullMQAdapter";
@@ -196,14 +196,29 @@ export default class Queue {
       jobId: sanitizedJobId,
     };
 
+    const queue: BullQueue = this.getQueue(queueName);
+
     if (options && options.scheduleAt) {
       optionsObject.repeat = {
         pattern: options.scheduleAt,
+        // keep repeatable job keyed by jobId so multiple workers do not register duplicates
+        jobId: sanitizedJobId,
       };
+
+      const repeatableJobs: RepeatableJob[] = await queue.getRepeatableJobs();
+
+      for (const repeatableJob of repeatableJobs) {
+        const isSameJob: boolean =
+          repeatableJob.name === jobName &&
+          repeatableJob.pattern === options.scheduleAt;
+
+        if (isSameJob) {
+          await queue.removeRepeatableByKey(repeatableJob.key);
+        }
+      }
     }
 
-    const job: Job | undefined =
-      await this.getQueue(queueName).getJob(sanitizedJobId);
+    const job: Job | undefined = await queue.getJob(sanitizedJobId);
 
     if (job) {
       await job.remove();
@@ -211,9 +226,7 @@ export default class Queue {
 
     if (options?.repeatableKey) {
       // remove existing repeatable job
-      await this.getQueue(queueName).removeRepeatableByKey(
-        options?.repeatableKey,
-      );
+      await queue.removeRepeatableByKey(options?.repeatableKey);
     }
 
     // Store repeatable jobs for re-adding on reconnect
@@ -228,11 +241,7 @@ export default class Queue {
       };
     }
 
-    const jobAdded: Job = await this.getQueue(queueName).add(
-      jobName,
-      data,
-      optionsObject,
-    );
+    const jobAdded: Job = await queue.add(jobName, data, optionsObject);
 
     return jobAdded;
   }

package/Server/Utils/Monitor/MonitorCriteriaEvaluator.ts

@@ -26,6 +26,7 @@ import MonitorEvaluationSummary, {
 } from "../../../Types/Monitor/MonitorEvaluationSummary";
 import ProbeApiIngestResponse from "../../../Types/Probe/ProbeApiIngestResponse";
 import ProbeMonitorResponse from "../../../Types/Probe/ProbeMonitorResponse";
+import RequestFailedDetails from "../../../Types/Probe/RequestFailedDetails";
 import IncomingMonitorRequest from "../../../Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
 import MonitorType from "../../../Types/Monitor/MonitorType";
 import { CheckOn, CriteriaFilter } from "../../../Types/Monitor/CriteriaFilter";
@@ -472,6 +473,7 @@ ${contextBlock}
   }): string | null {
     const requestDetails: Array<string> = [];
     const responseDetails: Array<string> = [];
+    const failureDetails: Array<string> = [];
 
     const probeResponse: ProbeMonitorResponse | null =
       MonitorCriteriaDataExtractor.getProbeMonitorResponse(input.dataToProcess);
@@ -526,6 +528,34 @@ ${contextBlock}
       );
     }
 
+    // Add Request Failed Details if available
+    if (probeResponse?.requestFailedDetails) {
+      const requestFailedDetails: RequestFailedDetails =
+        probeResponse.requestFailedDetails;
+
+      if (requestFailedDetails.failedPhase) {
+        failureDetails.push(
+          `- Failed Phase: ${requestFailedDetails.failedPhase}`,
+        );
+      }
+
+      if (requestFailedDetails.errorCode) {
+        failureDetails.push(`- Error Code: ${requestFailedDetails.errorCode}`);
+      }
+
+      if (requestFailedDetails.errorDescription) {
+        failureDetails.push(
+          `- Error Description: ${requestFailedDetails.errorDescription}`,
+        );
+      }
+
+      if (requestFailedDetails.rawErrorMessage) {
+        failureDetails.push(
+          `- Raw Error Message: ${requestFailedDetails.rawErrorMessage}`,
+        );
+      }
+    }
+
     const sections: Array<string> = [];
 
     if (requestDetails.length > 0) {
@@ -536,6 +566,12 @@ ${contextBlock}
       sections.push(`\n\n**Response Snapshot**\n${responseDetails.join("\n")}`);
     }
 
+    if (failureDetails.length > 0) {
+      sections.push(
+        `\n\n**Request Failed Details**\n${failureDetails.join("\n")}`,
+      );
+    }
+
     if (!sections.length) {
       return null;
     }

package/Types/Dashboard/DashboardComponents/ComponentArgument.ts

@@ -1,4 +1,5 @@
 import DashboardBaseComponent from "./DashboardBaseComponent";
+import { DropdownOption } from "../../../UI/Components/Dropdown/Dropdown";
 
 export enum ComponentInputType {
   Text = "Text",
@@ -9,6 +10,7 @@ export enum ComponentInputType {
   Decimal = "Decimal",
   MetricsQueryConfig = "MetricsQueryConfig",
   LongText = "Long Text",
+  Dropdown = "Dropdown",
 }
 
 export interface ComponentArgument<T extends DashboardBaseComponent> {
@@ -19,4 +21,5 @@ export interface ComponentArgument<T extends DashboardBaseComponent> {
   id: keyof T["arguments"];
   isAdvanced?: boolean | undefined;
   placeholder?: string | undefined;
+  dropdownOptions?: Array<DropdownOption> | undefined;
 }

package/Types/Dashboard/DashboardComponents/DashboardChartComponent.ts

@@ -1,6 +1,7 @@
 import MetricQueryConfigData from "../../Metrics/MetricQueryConfigData";
 import ObjectID from "../../ObjectID";
 import DashboardComponentType from "../DashboardComponentType";
+import DashboardChartType from "../Chart/ChartType";
 import BaseComponent from "./DashboardBaseComponent";
 
 export default interface DashboardChartComponent extends BaseComponent {
@@ -12,5 +13,6 @@ export default interface DashboardChartComponent extends BaseComponent {
     chartDescription?: string | undefined;
     legendText?: string | undefined;
     legendUnit?: string | undefined;
+    chartType?: DashboardChartType | undefined;
   };
 }

package/Types/Metrics/MetricQueryConfigData.ts

@@ -2,6 +2,11 @@ import AggregatedModel from "../BaseDatabase/AggregatedModel";
 import MetricAliasData from "./MetricAliasData";
 import MetricQueryData from "./MetricQueryData";
 
+export enum MetricChartType {
+  LINE = "line",
+  BAR = "bar",
+}
+
 export interface ChartSeries {
   title: string;
 }
@@ -10,4 +15,5 @@ export default interface MetricQueryConfigData {
   metricAliasData?: MetricAliasData | undefined;
   metricQueryData: MetricQueryData;
   getSeries?: ((data: AggregatedModel) => ChartSeries) | undefined;
+  chartType?: MetricChartType | undefined;
 }

package/Types/Monitor/NetworkMonitor/NetworkPathTrace.ts

@@ -0,0 +1,43 @@
+/**
+ * Represents a single hop in a network traceroute
+ */
+export interface TraceRouteHop {
+  hopNumber: number;
+  address: string | undefined; // IP address of the hop, undefined if the hop timed out
+  hostName: string | undefined; // Hostname of the hop if DNS lookup succeeded
+  roundTripTimeInMS: number | undefined; // RTT in milliseconds, undefined if timed out
+  isTimeout: boolean;
+}
+
+/**
+ * Represents the result of a traceroute operation
+ */
+export interface TraceRoute {
+  hops: Array<TraceRouteHop>;
+  destinationAddress: string;
+  destinationHostName: string | undefined;
+  isComplete: boolean; // Whether the traceroute reached the destination
+  totalHops: number;
+  failedHop: number | undefined; // The hop number where the route failed, if any
+  failureMessage: string | undefined; // Failure message at the failed hop
+}
+
+/**
+ * Represents DNS resolution information
+ */
+export interface DNSLookupResult {
+  hostName: string;
+  resolvedAddresses: Array<string>; // List of resolved IP addresses
+  resolvedInMS: number; // Time taken for DNS resolution
+  isSuccess: boolean;
+  errorMessage: string | undefined;
+}
+
+/**
+ * Complete network path diagnosis result combining DNS and traceroute
+ */
+export default interface NetworkPathTrace {
+  dnsLookup?: DNSLookupResult | undefined;
+  traceRoute?: TraceRoute | undefined;
+  timestamp: Date;
+}

package/Types/Probe/ProbeMonitorResponse.ts

@@ -9,6 +9,7 @@ import SyntheticMonitorResponse from "../Monitor/SyntheticMonitors/SyntheticMoni
 import MonitorEvaluationSummary from "../Monitor/MonitorEvaluationSummary";
 import ObjectID from "../ObjectID";
 import Port from "../Port";
+import RequestFailedDetails from "./RequestFailedDetails";
 
 export default interface ProbeMonitorResponse {
   projectId: ObjectID;
@@ -23,6 +24,7 @@ export default interface ProbeMonitorResponse {
   monitorId: ObjectID;
   probeId: ObjectID;
   failureCause: string;
+  requestFailedDetails?: RequestFailedDetails | undefined;
   sslResponse?: SslMonitorResponse | undefined;
   syntheticMonitorResponse?: Array<SyntheticMonitorResponse> | undefined;
   customCodeMonitorResponse?: CustomCodeMonitorResponse | undefined;

package/Types/Probe/RequestFailedDetails.ts

@@ -0,0 +1,36 @@
+/*
+ * This type holds detailed error context for when a request fails
+ * This helps users understand exactly where and why a request failed
+ */
+
+export enum RequestFailedPhase {
+  // DNS resolution failed - could not resolve hostname to IP
+  DNSResolution = "DNS Resolution",
+  // TCP connection failed - could not establish connection to server
+  TCPConnection = "TCP Connection",
+  // TLS/SSL handshake failed
+  TLSHandshake = "TLS Handshake",
+  // Request was sent but timed out waiting for response
+  RequestTimeout = "Request Timeout",
+  // Server responded with an error status code
+  ServerResponse = "Server Response",
+  // Request was aborted
+  RequestAborted = "Request Aborted",
+  // Network error - general network failure
+  NetworkError = "Network Error",
+  // Certificate error
+  CertificateError = "Certificate Error",
+  // Unknown error
+  Unknown = "Unknown",
+}
+
+export default interface RequestFailedDetails {
+  // The phase at which the request failed
+  failedPhase: RequestFailedPhase;
+  // The error code from axios/node (e.g., ECONNREFUSED, ETIMEDOUT, ENOTFOUND, etc.)
+  errorCode?: string | undefined;
+  // A detailed, user-friendly explanation of what went wrong
+  errorDescription: string;
+  // The raw error message (for debugging purposes)
+  rawErrorMessage?: string | undefined;
+}

package/UI/Components/Charts/Bar/BarChart.tsx

@@ -0,0 +1,76 @@
+import { BarChart } from "../ChartLibrary/BarChart/BarChart";
+import React, { FunctionComponent, ReactElement, useEffect } from "react";
+import SeriesPoint from "../Types/SeriesPoints";
+import { XAxis } from "../Types/XAxis/XAxis";
+import YAxis from "../Types/YAxis/YAxis";
+import ChartDataPoint from "../ChartLibrary/Types/ChartDataPoint";
+import DataPointUtil from "../Utils/DataPoint";
+
+export interface ComponentProps {
+  data: Array<SeriesPoint>;
+  xAxis: XAxis;
+  yAxis: YAxis;
+  sync: boolean;
+  heightInPx?: number | undefined;
+}
+
+export interface BarInternalProps extends ComponentProps {
+  syncid: string;
+}
+
+const BarChartElement: FunctionComponent<BarInternalProps> = (
+  props: BarInternalProps,
+): ReactElement => {
+  const [records, setRecords] = React.useState<Array<ChartDataPoint>>([]);
+
+  const categories: Array<string> = props.data.map((item: SeriesPoint) => {
+    return item.seriesName;
+  });
+
+  useEffect(() => {
+    if (!props.data || props.data.length === 0) {
+      setRecords([]);
+    }
+
+    const records: Array<ChartDataPoint> = DataPointUtil.getChartDataPoints({
+      seriesPoints: props.data,
+      xAxis: props.xAxis,
+      yAxis: props.yAxis,
+    });
+
+    setRecords(records);
+  }, [props.data]);
+
+  const className: string = props.heightInPx ? `` : "h-80";
+  const style: React.CSSProperties = props.heightInPx
+    ? { height: `${props.heightInPx}px` }
+    : {};
+
+  return (
+    <BarChart
+      className={className}
+      style={style}
+      data={records}
+      tickGap={1}
+      index={"Time"}
+      categories={categories}
+      colors={[
+        "indigo",
+        "rose",
+        "emerald",
+        "amber",
+        "cyan",
+        "gray",
+        "pink",
+        "lime",
+        "fuchsia",
+      ]}
+      valueFormatter={props.yAxis.options.formatter || undefined}
+      showTooltip={true}
+      yAxisWidth={60}
+      syncid={props.sync ? props.syncid : undefined}
+    />
+  );
+};
+
+export default BarChartElement;

package/UI/Components/Charts/ChartGroup/ChartGroup.tsx

@@ -1,5 +1,8 @@
 import Text from "../../../../Types/Text";
 import LineChart, { ComponentProps as LineChartProps } from "../Line/LineChart";
+import BarChartElement, {
+  ComponentProps as BarChartProps,
+} from "../Bar/BarChart";
 import React, { FunctionComponent, ReactElement } from "react";
 
 export enum ChartType {
@@ -13,7 +16,7 @@ export interface Chart {
   title: string;
   description?: string | undefined;
   type: ChartType;
-  props: LineChartProps;
+  props: LineChartProps | BarChartProps;
 }
 
 export interface ComponentProps {
@@ -55,7 +58,36 @@ const ChartGroup: FunctionComponent<ComponentProps> = (
                 )}
                 <LineChart
                   key={index}
-                  {...chart.props}
+                  {...(chart.props as LineChartProps)}
+                  syncid={syncId}
+                  heightInPx={props.heightInPx}
+                />
+              </div>
+            );
+          case ChartType.BAR:
+            return (
+              <div
+                key={index}
+                className={`p-6 ${props.hideCard ? "" : "rounded-md bg-white shadow"} ${props.chartCssClass || ""}`}
+              >
+                <h2
+                  data-testid="card-details-heading"
+                  id="card-details-heading"
+                  className="text-lg font-medium leading-6 text-gray-900"
+                >
+                  {chart.title}
+                </h2>
+                {chart.description && (
+                  <p
+                    data-testid="card-description"
+                    className="mt-1 text-sm text-gray-500 w-full hidden md:block"
+                  >
+                    {chart.description}
+                  </p>
+                )}
+                <BarChartElement
+                  key={index}
+                  {...(chart.props as BarChartProps)}
                   syncid={syncId}
                   heightInPx={props.heightInPx}
                 />

package/UI/Components/Charts/ChartLibrary/BarChart/BarChart.tsx

@@ -82,12 +82,42 @@ const renderShape: (
     width = Math.abs(width); // width must be a positive number
   }
 
+  // Radius for rounded corners at top
+  const radius: number = Math.min(4, width / 2, height / 2);
+
+  /*
+   * Create path with rounded corners at the top only (for horizontal layout)
+   * For vertical layout, round the right side
+   */
+  let path: string;
+
+  if (layout === "horizontal") {
+    // Rounded top corners for horizontal bars
+    path = `
+      M ${x},${y + height}
+      L ${x},${y + radius}
+      Q ${x},${y} ${x + radius},${y}
+      L ${x + width - radius},${y}
+      Q ${x + width},${y} ${x + width},${y + radius}
+      L ${x + width},${y + height}
+      Z
+    `;
+  } else {
+    // Rounded right corners for vertical bars
+    path = `
+      M ${x},${y}
+      L ${x + width - radius},${y}
+      Q ${x + width},${y} ${x + width},${y + radius}
+      L ${x + width},${y + height - radius}
+      Q ${x + width},${y + height} ${x + width - radius},${y + height}
+      L ${x},${y + height}
+      Z
+    `;
+  }
+
   return (
-    <rect
-      x={x}
-      y={y}
-      width={width}
-      height={height}
+    <path
+      d={path}
       opacity={
         activeBar || (activeLegend && activeLegend !== name)
           ? deepEqual(activeBar, { ...payload, value })
@@ -615,6 +645,7 @@ interface BarChartProps extends React.HTMLAttributes<HTMLDivElement> {
   legendPosition?: "left" | "center" | "right";
   tooltipCallback?: (tooltipCallbackContent: TooltipProps) => void;
   customTooltip?: React.ComponentType<TooltipProps>;
+  syncid?: string | undefined;
 }
 
 const BarChart: React.ForwardRefExoticComponent<
@@ -753,6 +784,7 @@ const BarChart: React.ForwardRefExoticComponent<
         <ResponsiveContainer>
           <RechartsBarChart
             data={data}
+            syncId={props.syncid?.toString() || ""}
             {...(hasOnValueChange && (activeLegend || activeBar)
               ? {
                   onClick: handleChartClick,