@oneuptime/common 10.0.37 → 10.0.39

package/Server/API/TelemetryAPI.ts

@@ -158,6 +158,10 @@ router.post(
         ? (body["spanIds"] as Array<string>)
         : undefined;
 
+      const attributes: Record<string, string> | undefined = body["attributes"]
+        ? (body["attributes"] as Record<string, string>)
+        : undefined;
+
       const request: HistogramRequest = {
         projectId: databaseProps.tenantId,
         startTime,
@@ -168,6 +172,7 @@ router.post(
         bodySearchText,
         traceIds,
         spanIds,
+        attributes,
       };
 
       const buckets: Array<HistogramBucket> =
@@ -242,6 +247,10 @@ router.post(
         ? (body["spanIds"] as Array<string>)
         : undefined;
 
+      const attributes: Record<string, string> | undefined = body["attributes"]
+        ? (body["attributes"] as Record<string, string>)
+        : undefined;
+
       const facets: Record<string, Array<FacetValue>> = {};
 
       for (const facetKey of facetKeys) {
@@ -256,6 +265,7 @@ router.post(
           bodySearchText,
           traceIds,
           spanIds,
+          attributes,
         };
 
         facets[facetKey] = await LogAggregationService.getFacetValues(request);

package/Server/Services/LogAggregationService.ts

@@ -25,6 +25,7 @@ export interface HistogramRequest {
   bodySearchText?: string | undefined;
   traceIds?: Array<string> | undefined;
   spanIds?: Array<string> | undefined;
+  attributes?: Record<string, string> | undefined;
 }
 
 export interface FacetValue {
@@ -43,6 +44,7 @@ export interface FacetRequest {
   bodySearchText?: string | undefined;
   traceIds?: Array<string> | undefined;
   spanIds?: Array<string> | undefined;
+  attributes?: Record<string, string> | undefined;
 }
 
 export type AnalyticsChartType = "timeseries" | "toplist" | "table";
@@ -589,7 +591,12 @@ export class LogAggregationService {
     statement: Statement,
     request: Pick<
       HistogramRequest,
-      "serviceIds" | "severityTexts" | "bodySearchText" | "traceIds" | "spanIds"
+      | "serviceIds"
+      | "severityTexts"
+      | "bodySearchText"
+      | "traceIds"
+      | "spanIds"
+      | "attributes"
     >,
   ): void {
     if (request.serviceIds && request.serviceIds.length > 0) {
@@ -640,6 +647,22 @@ export class LogAggregationService {
         }}`,
       );
     }
+
+    if (request.attributes && Object.keys(request.attributes).length > 0) {
+      for (const [attrKey, attrValue] of Object.entries(request.attributes)) {
+        LogAggregationService.validateFacetKey(attrKey);
+
+        statement.append(
+          SQL` AND attributes[${{
+            type: TableColumnType.Text,
+            value: attrKey,
+          }}] = ${{
+            type: TableColumnType.Text,
+            value: attrValue,
+          }}`,
+        );
+      }
+    }
   }
 
   @CaptureSpan()

package/Server/Types/Workflow/Components/Conditions/IfElse.ts

@@ -9,6 +9,7 @@ import ComponentMetadata, {
 import ComponentID from "../../../../../Types/Workflow/ComponentID";
 import Components, {
   ConditionOperator,
+  ConditionValueType,
 } from "../../../../../Types/Workflow/Components/Condition";
 import CaptureSpan from "../../../../Utils/Telemetry/CaptureSpan";
 
@@ -61,29 +62,75 @@ export default class IfElse extends ComponentCode {
        * Inject dependencies
        */
 
-      for (const key in args) {
-        if (key === "operator") {
-          continue;
-        }
-
-        const value: JSONValue = args[key];
+      // Get explicit types from dropdowns, default to text
+      let input1Type: ConditionValueType =
+        (args["input-1-type"] as ConditionValueType) || ConditionValueType.Text;
+      let input2Type: ConditionValueType =
+        (args["input-2-type"] as ConditionValueType) || ConditionValueType.Text;
 
-        let shouldHaveQuotes: boolean = false;
+      /*
+       * When types differ, coerce both to the more specific type
+       * so comparisons like text "true" == boolean true work correctly.
+       * Priority: Null/Undefined keep as-is, Boolean > Number > Text.
+       */
+      if (input1Type !== input2Type) {
+        type IsNullishFunction = (t: ConditionValueType) => boolean;
+
+        const isNullish: IsNullishFunction = (
+          t: ConditionValueType,
+        ): boolean => {
+          return (
+            t === ConditionValueType.Null || t === ConditionValueType.Undefined
+          );
+        };
 
-        if (
-          typeof value === "string" &&
-          value !== "null" &&
-          value !== "undefined"
-        ) {
-          shouldHaveQuotes = true;
+        if (!isNullish(input1Type) && !isNullish(input2Type)) {
+          const typePriority: Record<string, number> = {
+            [ConditionValueType.Boolean]: 2,
+            [ConditionValueType.Number]: 1,
+            [ConditionValueType.Text]: 0,
+          };
+
+          const p1: number = typePriority[input1Type] ?? 0;
+          const p2: number = typePriority[input2Type] ?? 0;
+          const commonType: ConditionValueType =
+            p1 >= p2 ? input1Type : input2Type;
+          input1Type = commonType;
+          input2Type = commonType;
         }
+      }
 
-        if (typeof value === "object") {
-          args[key] = JSON.stringify(args[key]);
+      type FormatValueFunction = (
+        value: JSONValue,
+        valueType: ConditionValueType,
+      ) => string;
+
+      const formatValue: FormatValueFunction = (
+        value: JSONValue,
+        valueType: ConditionValueType,
+      ): string => {
+        const strValue: string =
+          typeof value === "object"
+            ? JSON.stringify(value)
+            : String(value ?? "");
+
+        switch (valueType) {
+          case ConditionValueType.Boolean:
+            return strValue === "true" ? "true" : "false";
+          case ConditionValueType.Number:
+            return isNaN(Number(strValue)) ? "0" : String(Number(strValue));
+          case ConditionValueType.Null:
+            return "null";
+          case ConditionValueType.Undefined:
+            return "undefined";
+          case ConditionValueType.Text:
+          default:
+            return `"${strValue}"`;
         }
+      };
 
-        args[key] = shouldHaveQuotes ? `"${args[key]}"` : args[key];
-      }
+      args["input-1"] = formatValue(args["input-1"], input1Type);
+      args["input-2"] = formatValue(args["input-2"], input2Type);
 
       type SerializeFunction = (arg: string) => string;
 
@@ -107,13 +154,13 @@ export default class IfElse extends ComponentCode {
                     `;
 
       if (args["operator"] === ConditionOperator.Contains) {
-        code += `return input1.includes(input2);`;
+        code += `return String(input1).includes(String(input2));`;
       } else if (args["operator"] === ConditionOperator.DoesNotContain) {
-        code += `return !input1.includes(input2);`;
+        code += `return !String(input1).includes(String(input2));`;
       } else if (args["operator"] === ConditionOperator.StartsWith) {
-        code += `return input1.startsWith(input2);`;
+        code += `return String(input1).startsWith(String(input2));`;
       } else if (args["operator"] === ConditionOperator.EndsWith) {
-        code += `return input1.endsWith(input2);`;
+        code += `return String(input1).endsWith(String(input2));`;
       } else {
         code += `return input1 ${(args["operator"] as string) || "=="} input2;`;
       }

package/Server/Utils/Telemetry/Telemetry.ts

@@ -211,33 +211,50 @@ export default class TelemetryUtil {
     const jsonValue: JSONObject = value as JSONObject;
 
     if (jsonValue && typeof jsonValue === "object") {
-      if (Object.prototype.hasOwnProperty.call(jsonValue, "stringValue")) {
-        const stringValue: JSONValue = jsonValue["stringValue"];
+      // Handle both camelCase (JSON encoding) and snake_case (protobuf via protobufjs)
+      if (
+        Object.prototype.hasOwnProperty.call(jsonValue, "stringValue") ||
+        Object.prototype.hasOwnProperty.call(jsonValue, "string_value")
+      ) {
+        const stringValue: JSONValue =
+          jsonValue["stringValue"] ?? jsonValue["string_value"];
         finalObj =
           stringValue !== undefined && stringValue !== null
             ? (stringValue as string)
             : "";
-      } else if (Object.prototype.hasOwnProperty.call(jsonValue, "intValue")) {
-        const intValue: JSONValue = jsonValue["intValue"];
+      } else if (
+        Object.prototype.hasOwnProperty.call(jsonValue, "intValue") ||
+        Object.prototype.hasOwnProperty.call(jsonValue, "int_value")
+      ) {
+        const intValue: JSONValue =
+          jsonValue["intValue"] ?? jsonValue["int_value"];
         if (intValue !== undefined && intValue !== null) {
           finalObj = intValue as number;
         }
       } else if (
-        Object.prototype.hasOwnProperty.call(jsonValue, "doubleValue")
+        Object.prototype.hasOwnProperty.call(jsonValue, "doubleValue") ||
+        Object.prototype.hasOwnProperty.call(jsonValue, "double_value")
       ) {
-        const doubleValue: JSONValue = jsonValue["doubleValue"];
+        const doubleValue: JSONValue =
+          jsonValue["doubleValue"] ?? jsonValue["double_value"];
         if (doubleValue !== undefined && doubleValue !== null) {
           finalObj = doubleValue as number;
         }
-      } else if (Object.prototype.hasOwnProperty.call(jsonValue, "boolValue")) {
-        finalObj = jsonValue["boolValue"] as boolean;
       } else if (
-        jsonValue["arrayValue"] &&
-        (jsonValue["arrayValue"] as JSONObject)["values"]
+        Object.prototype.hasOwnProperty.call(jsonValue, "boolValue") ||
+        Object.prototype.hasOwnProperty.call(jsonValue, "bool_value")
+      ) {
+        finalObj = (jsonValue["boolValue"] ??
+          jsonValue["bool_value"]) as boolean;
+      } else if (
+        (jsonValue["arrayValue"] &&
+          (jsonValue["arrayValue"] as JSONObject)["values"]) ||
+        (jsonValue["array_value"] &&
+          (jsonValue["array_value"] as JSONObject)["values"])
       ) {
-        const values: JSONArray = (jsonValue["arrayValue"] as JSONObject)[
-          "values"
-        ] as JSONArray;
+        const arrayVal: JSONObject = (jsonValue["arrayValue"] ||
+          jsonValue["array_value"]) as JSONObject;
+        const values: JSONArray = arrayVal["values"] as JSONArray;
         finalObj = values.map((v: JSONObject) => {
           return this.getAttributeValues(
             prefixKeysWithString,
@@ -290,17 +307,19 @@ export default class TelemetryUtil {
 
         finalObj = flattenedFields;
       } else if (
-        jsonValue["kvlistValue"] &&
-        (jsonValue["kvlistValue"] as JSONObject)["values"]
+        (jsonValue["kvlistValue"] &&
+          (jsonValue["kvlistValue"] as JSONObject)["values"]) ||
+        (jsonValue["kvlist_value"] &&
+          (jsonValue["kvlist_value"] as JSONObject)["values"])
       ) {
-        const values: JSONArray = (jsonValue["kvlistValue"] as JSONObject)[
-          "values"
-        ] as JSONArray;
+        const kvlistVal: JSONObject = (jsonValue["kvlistValue"] ||
+          jsonValue["kvlist_value"]) as JSONObject;
+        const values: JSONArray = kvlistVal["values"] as JSONArray;
         finalObj = this.getAttributes({
           prefixKeysWithString,
           items: values,
         });
-      } else if ("nullValue" in jsonValue) {
+      } else if ("nullValue" in jsonValue || "null_value" in jsonValue) {
         finalObj = null;
       }
     }

package/Types/Workflow/Component.ts

@@ -26,6 +26,7 @@ export enum ComponentInputType {
   HTML = "HTML",
   Operator = "Operator",
   Markdown = "Markdown",
+  ValueType = "Value Type",
 }
 
 export enum ComponentType {

package/Types/Workflow/Components/Condition.ts

@@ -5,6 +5,14 @@ import ComponentMetadata, {
   ComponentType,
 } from "./../Component";
 
+export enum ConditionValueType {
+  Text = "text",
+  Boolean = "boolean",
+  Number = "number",
+  Null = "null",
+  Undefined = "undefined",
+}
+
 export enum ConditionOperator {
   EqualTo = "==",
   NotEqualTo = "!=",
@@ -27,6 +35,14 @@ const components: Array<ComponentMetadata> = [
     iconProp: IconProp.Condition,
     componentType: ComponentType.Component,
     arguments: [
+      {
+        type: ComponentInputType.ValueType,
+        name: "Input 1 Type",
+        description: "Type of Input 1. Defaults to Text if not selected.",
+        placeholder: "Text",
+        required: false,
+        id: "input-1-type",
+      },
       {
         type: ComponentInputType.Text,
         name: "Input 1",
@@ -43,6 +59,14 @@ const components: Array<ComponentMetadata> = [
         required: true,
         id: "operator",
       },
+      {
+        type: ComponentInputType.ValueType,
+        name: "Input 2 Type",
+        description: "Type of Input 2. Defaults to Text if not selected.",
+        placeholder: "Text",
+        required: false,
+        id: "input-2-type",
+      },
       {
         type: ComponentInputType.Text,
         name: "Input 2",

package/UI/Components/Charts/Area/AreaChart.tsx

@@ -0,0 +1,81 @@
+import { AreaChart } from "../ChartLibrary/AreaChart/AreaChart";
+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 ChartCurve from "../Types/ChartCurve";
+import ChartDataPoint from "../ChartLibrary/Types/ChartDataPoint";
+import DataPointUtil from "../Utils/DataPoint";
+
+export interface ComponentProps {
+  data: Array<SeriesPoint>;
+  xAxis: XAxis;
+  yAxis: YAxis;
+  curve: ChartCurve;
+  sync: boolean;
+  heightInPx?: number | undefined;
+}
+
+export interface AreaInternalProps extends ComponentProps {
+  syncid: string;
+}
+
+const AreaChartElement: FunctionComponent<AreaInternalProps> = (
+  props: AreaInternalProps,
+): 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 (
+    <AreaChart
+      className={className}
+      style={style}
+      data={records}
+      tickGap={1}
+      index={"Time"}
+      categories={categories}
+      colors={[
+        "blue",
+        "emerald",
+        "violet",
+        "amber",
+        "cyan",
+        "pink",
+        "lime",
+        "fuchsia",
+        "indigo",
+        "rose",
+      ]}
+      valueFormatter={props.yAxis.options.formatter || undefined}
+      showTooltip={true}
+      connectNulls={true}
+      curve={props.curve || ChartCurve.MONOTONE}
+      syncid={props.sync ? props.syncid : undefined}
+      yAxisWidth={60}
+    />
+  );
+};
+
+export default AreaChartElement;

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

@@ -3,6 +3,9 @@ import LineChart, { ComponentProps as LineChartProps } from "../Line/LineChart";
 import BarChartElement, {
   ComponentProps as BarChartProps,
 } from "../Bar/BarChart";
+import AreaChartElement, {
+  ComponentProps as AreaChartProps,
+} from "../Area/AreaChart";
 import React, { FunctionComponent, ReactElement } from "react";
 
 export enum ChartType {
@@ -16,7 +19,7 @@ export interface Chart {
   title: string;
   description?: string | undefined;
   type: ChartType;
-  props: LineChartProps | BarChartProps;
+  props: LineChartProps | BarChartProps | AreaChartProps;
 }
 
 export interface ComponentProps {
@@ -31,71 +34,111 @@ const ChartGroup: FunctionComponent<ComponentProps> = (
 ): ReactElement => {
   const syncId: string = Text.generateRandomText(10);
 
+  const isLastChart: (index: number) => boolean = (index: number): boolean => {
+    return index === props.charts.length - 1;
+  };
+
+  type GetChartContentFunction = (chart: Chart, index: number) => ReactElement;
+
+  const getChartContent: GetChartContentFunction = (
+    chart: Chart,
+    index: number,
+  ): ReactElement => {
+    switch (chart.type) {
+      case ChartType.LINE:
+        return (
+          <LineChart
+            key={index}
+            {...(chart.props as LineChartProps)}
+            syncid={syncId}
+            heightInPx={props.heightInPx}
+          />
+        );
+      case ChartType.BAR:
+        return (
+          <BarChartElement
+            key={index}
+            {...(chart.props as BarChartProps)}
+            syncid={syncId}
+            heightInPx={props.heightInPx}
+          />
+        );
+      case ChartType.AREA:
+        return (
+          <AreaChartElement
+            key={index}
+            {...(chart.props as AreaChartProps)}
+            syncid={syncId}
+            heightInPx={props.heightInPx}
+          />
+        );
+      default:
+        return <></>;
+    }
+  };
+
+  // When hideCard is true, render charts in a clean vertical stack with dividers
+  if (props.hideCard) {
+    return (
+      <div className="space-y-0">
+        {props.charts.map((chart: Chart, index: number) => {
+          return (
+            <div
+              key={index}
+              className={`${!isLastChart(index) ? "border-b border-gray-100" : ""} ${props.chartCssClass || ""}`}
+            >
+              <div className="px-1 pt-5 pb-4">
+                <div className="mb-1">
+                  <h3 className="text-sm font-semibold text-gray-700 tracking-tight">
+                    {chart.title}
+                  </h3>
+                  {chart.description && (
+                    <p className="mt-0.5 text-xs text-gray-400 hidden md:block">
+                      {chart.description}
+                    </p>
+                  )}
+                </div>
+                {getChartContent(chart, index)}
+              </div>
+            </div>
+          );
+        })}
+      </div>
+    );
+  }
+
+  // When showing cards, use the grid layout
+  const gridCols: string =
+    props.charts.length > 1 ? "lg:grid-cols-2" : "lg:grid-cols-1";
+
   return (
-    <div className="lg:grid grid-cols-1 gap-5 space-y-5 lg:space-y-0">
+    <div
+      className={`grid grid-cols-1 ${gridCols} gap-4 space-y-4 lg:space-y-0`}
+    >
       {props.charts.map((chart: Chart, index: number) => {
-        switch (chart.type) {
-          case ChartType.LINE:
-            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>
-                )}
-                <LineChart
-                  key={index}
-                  {...(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 || ""}`}
+        return (
+          <div
+            key={index}
+            className={`p-5 rounded-lg border border-gray-200 bg-white shadow-sm ${props.chartCssClass || ""}`}
+          >
+            <h2
+              data-testid="card-details-heading"
+              id="card-details-heading"
+              className="text-base font-semibold leading-6 text-gray-900"
+            >
+              {chart.title}
+            </h2>
+            {chart.description && (
+              <p
+                data-testid="card-description"
+                className="mt-0.5 text-sm text-gray-500 w-full hidden md:block"
               >
-                <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}
-                />
-              </div>
-            );
-          default:
-            return <></>;
-        }
+                {chart.description}
+              </p>
+            )}
+            {getChartContent(chart, index)}
+          </div>
+        );
       })}
     </div>
   );