WIP: tracing support incomplete, see FIXME comments.

Author: alanconway

web/src/__tests__/trace-node.spec.ts

@@ -0,0 +1,22 @@
+import { TraceNode } from '../korrel8r/trace';
+
+const roundtrip = [
+  {
+    url: `observe/traces?tempostack=NAME&namespace=NAMESPACE&tenant=TENANT&q=${encodeURIComponent(
+      '{resource.service.name = "article-service"}',
+    )}`,
+    query: `trace:trace:{resource.service.name = "article-service"}`,
+  },
+];
+
+describe('TraceNode.fromURL', () => {
+  it.each(roundtrip)('$url', ({ url, query }) =>
+    expect(TraceNode.fromURL(url)?.toQuery()).toEqual(query),
+  );
+});
+
+describe('TraceNode.fromQuery', () => {
+  it.each(roundtrip)('$query', ({ query, url }) =>
+    expect(TraceNode.fromQuery(query)?.toURL()).toEqual(url),
+  );
+});

web/src/korrel8r/korrel8r.types.ts

@@ -4,6 +4,7 @@ export enum Korrel8rDomain {
   Alert = 'alert',
   K8s = 'k8s',
   Log = 'log',
+  Trace = 'trace',
 }
 
 export abstract class Korrel8rNode {
@@ -18,3 +19,10 @@ export class NodeError extends Error {
     super(reason);
   }
 }
+
+// Thrown when a URL or Query does not match the Korrel8rNode class trying to parse it.
+export class WrongDomainError extends NodeError {
+  constructor(reason: string) {
+    super(reason);
+  }
+}

web/src/korrel8r/node-factory.ts

@@ -1,37 +1,46 @@
-import { Korrel8rNode } from './korrel8r.types';
-
 import { AlertNode } from './alert';
+import { InvalidNode } from './invalid';
+import { K8sNode } from './k8s';
+import { Korrel8rNode, WrongDomainError } from './korrel8r.types';
 import { LogNode } from './log';
 import { MetricNode } from './metric';
 import { NetflowNode } from './netflow';
-import { K8sNode } from './k8s';
+import { TraceNode } from './trace';
 
 export class Korrel8rNodeFactory {
   static fromURL(url: string): Korrel8rNode {
-    if (url.startsWith('monitoring/alerts')) {
-      return AlertNode.fromURL(url);
-    } else if (url.startsWith('monitoring/logs')) {
-      return LogNode.fromURL(url);
-    } else if (url.startsWith('monitoring/query-browser')) {
-      return MetricNode.fromURL(url);
-    } else if (url.startsWith('netflow-traffic')) {
-      return NetflowNode.fromURL(url);
-    } else {
-      return K8sNode.fromURL(url);
-    }
+    [
+      AlertNode.fromURL,
+      K8sNode.fromURL,
+      LogNode.fromURL,
+      MetricNode.fromURL,
+      NetflowNode.fromURL,
+      TraceNode.fromURL,
+    ].forEach((fromURL): Korrel8rNode => {
+      try {
+        // eslint-disable-next-line no-console
+        console.error(`FIXME ${fromURL} ${url}`);
+        return fromURL(url);
+      } catch (e) {
+        if (!(e instanceof WrongDomainError)) {
+          throw e;
+        }
+      }
+    });
+    return InvalidNode.fromURL(url);
   }
+
   static fromQuery(query: string): Korrel8rNode {
-    switch (query.split(':').at(0)) {
-      case 'alert':
-        return AlertNode.fromQuery(query);
-      case 'log':
-        return LogNode.fromQuery(query);
-      case 'metric':
-        return MetricNode.fromQuery(query);
-      case 'netflow':
-        return NetflowNode.fromQuery(query);
-      default:
-        return K8sNode.fromQuery(query);
-    }
+    const lookup = {
+      alert: AlertNode.fromQuery,
+      k8s: K8sNode.fromQuery,
+      log: LogNode.fromQuery,
+      metric: MetricNode.fromQuery,
+      netflow: NetflowNode.fromQuery,
+      trace: TraceNode.fromQuery,
+    };
+    const fromQuery = lookup[query.split(':').at(0)];
+    if (fromQuery) return fromQuery(query);
+    return InvalidNode.fromQuery(query);
   }
 }

web/src/korrel8r/query-url.ts

@@ -1,4 +1,4 @@
-import { NodeError } from './korrel8r.types';
+import { NodeError, WrongDomainError } from './korrel8r.types';
 
 // Return URL path and query parameters. Throw if URL does not match pattern.
 export const parseURL = (
@@ -7,7 +7,7 @@ export const parseURL = (
   url: string,
 ): [path: string, params: URLSearchParams] => {
   if (pattern && !url.match(new RegExp(`(${pattern})([/?]|$)`))) {
-    throw new NodeError(`Expected ${domain} URL: ${url}`);
+    throw new WrongDomainError(`Expected ${domain} URL: ${url}`);
   }
   try {
     const u = new URL(url, 'http://dummy'); // Need dummy scheme & host for URL parser.

web/src/korrel8r/trace.ts

@@ -1,6 +1,12 @@
 import { Korrel8rNode } from './korrel8r.types';
 import { parseQuery, parseURL } from './query-url';
 
+// URL format: `observe/traces?namespace=<tempoNamespace>&name=<tempoName>&tenant=<tempoTenant>&q=<traceQL>` +
+
+// FIXME hard-coded tempo location, need to make this configurable/agreed between console & korrel8r.
+// Get from the console page environment (change from using URL as context?)
+const [tempoNamespace, tempoName, tempoTenant] = ['NAMESPACE', 'NAME', 'TENANT'];
+
 export class TraceNode extends Korrel8rNode {
   query: string;
   url: string;
@@ -11,18 +17,18 @@ export class TraceNode extends Korrel8rNode {
     this.url = url;
   }
 
-  // TODO: Add support for pulling parameters from filter query parameters
   static fromURL(url: string): Korrel8rNode {
     const [, params] = parseURL('trace', 'observe/traces', url);
     const traceQL = params.get('q');
+    // FIXME need to handle store location params also.
     return new TraceNode(url, `trace:trace:${traceQL}`);
   }
 
   static fromQuery(query: string): Korrel8rNode {
     const [, traceQL] = parseQuery('trace', query);
     // FIME get variable tempo address info from query or config...
     return new TraceNode(
-      `observe/traces?namespace=openshift-tracing&name=platform&tenant=platform&` +
+      `observe/traces?tempostack=${tempoName}&namespace=${tempoNamespace}&tenant=${tempoTenant}&` +
         `q=${encodeURIComponent(traceQL)}`,
       query,
     );