@oneuptime/common 10.0.20 → 10.0.21

package/Types/Log/LogQueryParser.ts

@@ -0,0 +1,252 @@
+/**
+ * LogQueryParser
+ *
+ * Parses a Datadog-style log search query string into structured filter tokens.
+ *
+ * Supported syntax:
+ *   - Free text:           `connection refused`       → body ILIKE '%connection refused%'
+ *   - Quoted phrase:       `"connection refused"`     → body ILIKE '%connection refused%'
+ *   - Field-specific:      `severity:error`           → severityText = 'error'
+ *   - Attribute access:    `@http.status_code:500`    → attributes.http.status_code = '500'
+ *   - Negation (prefix):   `-severity:debug`          → severityText != 'debug'
+ *   - Wildcard:            `service:api-*`            → serviceId ILIKE 'api-%'
+ *   - Numeric range:       `@duration:>1000`          → attributes.duration > 1000
+ *   - Boolean:             `severity:error AND service:api` (AND is default between tokens)
+ *
+ * Produces an array of ParsedToken objects consumed by the search bar and query builder.
+ */
+
+export enum TokenType {
+  FreeText = "FreeText",
+  FieldFilter = "FieldFilter",
+  AttributeFilter = "AttributeFilter",
+}
+
+export enum FilterOperator {
+  Equals = "Equals",
+  NotEquals = "NotEquals",
+  Contains = "Contains",
+  NotContains = "NotContains",
+  GreaterThan = "GreaterThan",
+  GreaterThanOrEqual = "GreaterThanOrEqual",
+  LessThan = "LessThan",
+  LessThanOrEqual = "LessThanOrEqual",
+  Wildcard = "Wildcard",
+}
+
+export interface ParsedToken {
+  type: TokenType;
+  field?: string;
+  operator: FilterOperator;
+  value: string;
+  negated: boolean;
+  raw: string;
+}
+
+const FIELD_ALIASES: Record<string, string> = {
+  severity: "severityText",
+  level: "severityText",
+  service: "serviceId",
+  trace: "traceId",
+  span: "spanId",
+  message: "body",
+  msg: "body",
+  log: "body",
+};
+
+const BOOLEAN_KEYWORDS: Set<string> = new Set(["AND", "OR", "NOT"]);
+
+function resolveFieldName(raw: string): string {
+  const lower: string = raw.toLowerCase();
+  return FIELD_ALIASES[lower] || raw;
+}
+
+function detectOperator(value: string): {
+  operator: FilterOperator;
+  cleanValue: string;
+} {
+  if (value.startsWith(">=")) {
+    return {
+      operator: FilterOperator.GreaterThanOrEqual,
+      cleanValue: value.slice(2),
+    };
+  }
+
+  if (value.startsWith("<=")) {
+    return {
+      operator: FilterOperator.LessThanOrEqual,
+      cleanValue: value.slice(2),
+    };
+  }
+
+  if (value.startsWith(">")) {
+    return {
+      operator: FilterOperator.GreaterThan,
+      cleanValue: value.slice(1),
+    };
+  }
+
+  if (value.startsWith("<")) {
+    return {
+      operator: FilterOperator.LessThan,
+      cleanValue: value.slice(1),
+    };
+  }
+
+  if (value.includes("*")) {
+    return {
+      operator: FilterOperator.Wildcard,
+      cleanValue: value,
+    };
+  }
+
+  return {
+    operator: FilterOperator.Equals,
+    cleanValue: value,
+  };
+}
+
+function tokenizeRawInput(input: string): Array<string> {
+  const tokens: Array<string> = [];
+  let current: string = "";
+  let inQuotes: boolean = false;
+
+  for (let i: number = 0; i < input.length; i++) {
+    const char: string = input[i]!;
+
+    if (char === '"') {
+      inQuotes = !inQuotes;
+      current += char;
+      continue;
+    }
+
+    if (char === " " && !inQuotes) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current.length > 0) {
+    tokens.push(current);
+  }
+
+  return tokens;
+}
+
+function stripQuotes(value: string): string {
+  if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+function parseFieldToken(raw: string): ParsedToken {
+  let workingRaw: string = raw;
+  let negated: boolean = false;
+
+  if (workingRaw.startsWith("-")) {
+    negated = true;
+    workingRaw = workingRaw.slice(1);
+  }
+
+  const isAttribute: boolean = workingRaw.startsWith("@");
+
+  if (isAttribute) {
+    workingRaw = workingRaw.slice(1);
+  }
+
+  const colonIndex: number = workingRaw.indexOf(":");
+
+  if (colonIndex === -1) {
+    return {
+      type: TokenType.FreeText,
+      operator: FilterOperator.Contains,
+      value: stripQuotes(workingRaw),
+      negated,
+      raw,
+    };
+  }
+
+  const rawField: string = workingRaw.slice(0, colonIndex);
+  const rawValue: string = stripQuotes(workingRaw.slice(colonIndex + 1));
+
+  const { operator, cleanValue } = detectOperator(rawValue);
+
+  const field: string = isAttribute ? rawField : resolveFieldName(rawField);
+
+  return {
+    type: isAttribute ? TokenType.AttributeFilter : TokenType.FieldFilter,
+    field,
+    operator:
+      negated && operator === FilterOperator.Equals
+        ? FilterOperator.NotEquals
+        : operator,
+    value: cleanValue,
+    negated,
+    raw,
+  };
+}
+
+export function parseLogQuery(query: string): Array<ParsedToken> {
+  const trimmed: string = query.trim();
+
+  if (trimmed.length === 0) {
+    return [];
+  }
+
+  const rawTokens: Array<string> = tokenizeRawInput(trimmed);
+  const tokens: Array<ParsedToken> = [];
+  const freeTextParts: Array<string> = [];
+
+  const flushFreeText: () => void = (): void => {
+    if (freeTextParts.length > 0) {
+      const combined: string = freeTextParts.join(" ");
+      tokens.push({
+        type: TokenType.FreeText,
+        operator: FilterOperator.Contains,
+        value: combined,
+        negated: false,
+        raw: combined,
+      });
+      freeTextParts.length = 0;
+    }
+  };
+
+  for (const rawToken of rawTokens) {
+    if (BOOLEAN_KEYWORDS.has(rawToken)) {
+      continue;
+    }
+
+    const hasColon: boolean =
+      rawToken.includes(":") && !rawToken.startsWith('"');
+
+    const isNegatedField: boolean =
+      rawToken.startsWith("-") && rawToken.slice(1).includes(":");
+
+    if (hasColon || isNegatedField) {
+      flushFreeText();
+      tokens.push(parseFieldToken(rawToken));
+    } else {
+      freeTextParts.push(stripQuotes(rawToken));
+    }
+  }
+
+  flushFreeText();
+
+  return tokens;
+}
+
+export function tokensToDisplayString(tokens: Array<ParsedToken>): string {
+  return tokens
+    .map((t: ParsedToken) => {
+      return t.raw;
+    })
+    .join(" ");
+}
+
+export default parseLogQuery;

package/Types/Log/LogQueryToFilter.ts

@@ -0,0 +1,131 @@
+/**
+ * Converts parsed log query tokens into a Query<Log> object compatible with
+ * the AnalyticsDatabaseService query system.
+ */
+
+import {
+  ParsedToken,
+  TokenType,
+  FilterOperator,
+  parseLogQuery,
+} from "./LogQueryParser";
+import Search from "../BaseDatabase/Search";
+import GreaterThan from "../BaseDatabase/GreaterThan";
+import GreaterThanOrEqual from "../BaseDatabase/GreaterThanOrEqual";
+import LessThan from "../BaseDatabase/LessThan";
+import LessThanOrEqual from "../BaseDatabase/LessThanOrEqual";
+
+export interface LogFilter {
+  body?: string | Search<string>;
+  severityText?: string;
+  serviceId?: string;
+  traceId?: string;
+  spanId?: string;
+  attributes?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+const TOP_LEVEL_FIELDS: Set<string> = new Set([
+  "severityText",
+  "serviceId",
+  "traceId",
+  "spanId",
+  "body",
+]);
+
+function applyFieldFilter(filter: LogFilter, token: ParsedToken): void {
+  if (!token.field) {
+    return;
+  }
+
+  const value: string = token.value;
+
+  if (TOP_LEVEL_FIELDS.has(token.field)) {
+    applyTopLevelFilter(filter, token.field, value, token.operator);
+  } else {
+    applyAttributeFilter(filter, token.field, value, token.operator);
+  }
+}
+
+function applyTopLevelFilter(
+  filter: LogFilter,
+  field: string,
+  value: string,
+  operator: FilterOperator,
+): void {
+  switch (operator) {
+    case FilterOperator.Contains:
+    case FilterOperator.Wildcard:
+      filter[field] = new Search(value.replace(/\*/g, ""));
+      break;
+    case FilterOperator.GreaterThan:
+      filter[field] = new GreaterThan(parseNumericOrString(value));
+      break;
+    case FilterOperator.GreaterThanOrEqual:
+      filter[field] = new GreaterThanOrEqual(parseNumericOrString(value));
+      break;
+    case FilterOperator.LessThan:
+      filter[field] = new LessThan(parseNumericOrString(value));
+      break;
+    case FilterOperator.LessThanOrEqual:
+      filter[field] = new LessThanOrEqual(parseNumericOrString(value));
+      break;
+    case FilterOperator.Equals:
+    case FilterOperator.NotEquals:
+    default:
+      filter[field] = value;
+      break;
+  }
+}
+
+function applyAttributeFilter(
+  filter: LogFilter,
+  field: string,
+  value: string,
+  _operator: FilterOperator,
+): void {
+  if (!filter.attributes) {
+    filter.attributes = {};
+  }
+
+  filter.attributes[field] = value;
+}
+
+function applyFreeTextFilter(filter: LogFilter, token: ParsedToken): void {
+  if (filter.body && filter.body instanceof Search) {
+    const existing: string = filter.body.toString();
+    filter.body = new Search(`${existing} ${token.value}`);
+  } else if (filter.body && typeof filter.body === "string") {
+    filter.body = new Search(`${filter.body} ${token.value}`);
+  } else {
+    filter.body = new Search(token.value);
+  }
+}
+
+function parseNumericOrString(value: string): number | string {
+  const num: number = Number(value);
+  return isNaN(num) ? value : num;
+}
+
+export function queryStringToFilter(queryString: string): LogFilter {
+  const tokens: Array<ParsedToken> = parseLogQuery(queryString);
+  const filter: LogFilter = {};
+
+  for (const token of tokens) {
+    switch (token.type) {
+      case TokenType.FreeText:
+        applyFreeTextFilter(filter, token);
+        break;
+      case TokenType.FieldFilter:
+        applyFieldFilter(filter, token);
+        break;
+      case TokenType.AttributeFilter:
+        applyFieldFilter(filter, token);
+        break;
+    }
+  }
+
+  return filter;
+}
+
+export default queryStringToFilter;

package/UI/Components/CopyTextButton/CopyTextButton.tsx

@@ -54,14 +54,14 @@ const CopyTextButton: FunctionComponent<ComponentProps> = (
 
   const variantClasses: Record<typeof variant, string> = {
     ghost:
-      "bg-transparent border border-slate-600 text-slate-300 hover:bg-slate-700/40",
-    soft: "bg-slate-700 text-white border border-slate-600 hover:bg-slate-600",
+      "bg-transparent border border-gray-200 text-gray-400 hover:bg-gray-50 hover:text-gray-600",
+    soft: "bg-gray-100 text-gray-600 border border-gray-200 hover:bg-gray-200",
     solid:
       "bg-indigo-600 text-white border border-indigo-600 hover:bg-indigo-500",
   } as const;
 
   const copiedClasses: string =
-    "bg-emerald-600/20 border border-emerald-500 text-emerald-300";
+    "bg-emerald-50 border border-emerald-200 text-emerald-600";
 
   return (
     <button