Feat/grafana tools (#21)

This pull request introduces new clients for interacting with Grafana and Loki, and includes corresponding test files for each client. The changes add functionality for fetching dashboards and logs, as well as querying specific data from these services.

Author: danielpaulus

src/grafana/grafanaclient.spec.ts

@@ -0,0 +1,27 @@
+import { GrafanaClient } from './grafanaclient';
+import 'dotenv/config';
+
+const grafanaApiKey = process.env.GRAFANA_API_KEY!;
+const grafanaUrl = process.env.GRAFANA_INSTANCE_URL!;
+const isGithubActions = process.env.GITHUB_ACTIONS === 'true';
+const maybe = !isGithubActions ? describe : describe.skip;
+
+maybe('GrafanaClient', () => {
+  let grafanaClient: GrafanaClient;
+
+  beforeAll(() => {
+    grafanaClient = new GrafanaClient(grafanaUrl, grafanaApiKey);
+  });
+
+  it('should get dashboards', async () => {
+    const dashboards = await grafanaClient.getDashboards();
+    expect(dashboards).toBeDefined();
+    
+    expect(Array.isArray(dashboards)).toBe(true);
+
+    const db = 'Runners Overview'
+    const dashboard = await grafanaClient.getDashboardUrlByName(db);
+    expect(dashboard).toBeDefined();
+  });
+
+});

src/grafana/grafanaclient.ts

@@ -0,0 +1,32 @@
+export class GrafanaClient {
+    private readonly grafanaUrl: string;
+    private readonly grafanaApiKey: string;
+
+    constructor(grafanaUrl: string, grafanaApiKey: string) {
+      this.grafanaUrl = grafanaUrl;
+      this.grafanaApiKey = grafanaApiKey;
+    }
+
+   async getDashboardUrlByName(dashboardName: string): Promise<string> {
+    const dashboards = await this.getDashboards();
+    const runners = dashboards.filter(d=>d.type==='dash-db' ).filter(d=>d.title.toLowerCase().includes(dashboardName.toLowerCase()))[0]
+    return runners.url
+   }
+
+    async getDashboards(): Promise<any[]> {
+        const url = `${this.grafanaUrl}/api/search`;
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.grafanaApiKey}`
+      }
+    });
+
+    if (!response.ok) {
+      throw new Error(`Error fetching dashboards: ${response.statusText}`);
+    }
+
+    return response.json();
+    }
+}

src/grafana/lokiclient.spec.ts

@@ -0,0 +1,41 @@
+import { LokiClient } from './lokiclient';
+import 'dotenv/config';
+const lokiApiKey = process.env.LOKI_API_KEY!;
+const user = process.env.LOKI_USER!;
+const lokiUrl = process.env.LOKI_URL!;
+const isGithubActions = process.env.GITHUB_ACTIONS === 'true';
+const maybe = !isGithubActions ? describe : describe.skip;
+jest.setTimeout(30000);
+maybe('LokiClient', () => {
+  let lokiClient: LokiClient;
+
+  beforeAll(() => {
+    lokiClient = new LokiClient(lokiUrl, lokiApiKey, user, "staging");
+  });
+
+  it ('can count logs by level for a service', async () => {
+    const service = "checkly-api";
+    const rangeMinutes = 60*12;
+    const data = await lokiClient.getLogCountByLevel(service, rangeMinutes);
+    expect(data).toBeDefined();
+    console.log(JSON.stringify(data.data.result));
+    expect(data).toHaveProperty('data');
+    //console.log(JSON.stringify(data.data.result[0].values));
+  })
+
+  it('should get available services', async () => {
+    const services = await lokiClient.getAllValuesForLabel("app");
+    expect(services).toBeDefined();
+    expect(services.length).toBeGreaterThan(0);
+    //console.log(services);
+  });
+  
+  it('should run a query and return results', async () => {
+    const services = lokiClient.getAllValuesForLabel("app");
+    const data = await lokiClient.getErrorsForService(services[1], 10);
+    expect(data).toBeDefined();
+    expect(data).toHaveProperty('data');
+    //console.log(JSON.stringify(data.data.result[0].values));
+  });
+});
+  

src/grafana/lokiclient.ts

@@ -0,0 +1,94 @@
+export class LokiClient {
+    private readonly lokiUrl: string;
+    private readonly lokiApiKey: string;
+    private readonly environment: string;
+    user: string;
+  
+    constructor(lokiUrl: string, lokiApiKey: string, user: string, environment: string) {
+      this.lokiUrl = lokiUrl;
+      this.lokiApiKey = lokiApiKey;
+      this.environment = environment;
+      this.user = user;
+    }
+  
+    queryError(service: string): string {
+      return `{app="${service}", env="${this.environment}"} |= "error"`;
+    }
+
+   async getLogCountByLevel(app: string, rangeMinutes: number): Promise<any> {
+        const query = `sum by (detected_level) (count_over_time({app="${app}", env="${this.environment}"}[5m]))`;
+        const end = new Date();
+        const start = new Date(end.getTime() - rangeMinutes * 60 * 1000);
+        const data = await this.queryLoki(query, start.toISOString(), end.toISOString());
+        return data;
+    }
+
+    async getAllEnvironments(): Promise<string[]> {
+        return this.getAllValuesForLabel('env');
+    }
+
+   
+    async getAllApps(): Promise<string[]> {
+        return this.getAllValuesForLabel('app');
+    }
+
+    /**
+     * This function gets all available values for a label in Loki. 
+     * @returns 
+     */
+    async getAllValuesForLabel(label: string): Promise<string[]> {
+        const url = new URL(`${this.lokiUrl}/loki/api/v1/label/${label}/values`);
+        const authHeader = 'Basic ' + btoa(`${this.user}:${this.lokiApiKey}`);
+    
+        const response = await fetch(url.toString(), {
+          method: 'GET',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': authHeader
+          }
+        });
+    
+        if (!response.ok) {
+          throw new Error(`Error fetching available services: ${response.statusText}`);
+        }
+    
+        const data = await response.json();
+        return data.data; // Assuming the response structure is { "status": "success", "data": ["app1", "app2", ...] }
+      }
+
+    async getErrorsForService(service: string, rangeMinutes: number) {
+      // Get the current time and subtract "rangeMinutes" minutes
+      const end = new Date();
+      const start = new Date(end.getTime() - rangeMinutes * 60 * 1000);
+  
+      // Convert to ISO string format
+      const startISOString = start.toISOString();
+      const endISOString = end.toISOString();
+      const query = this.queryError(service);
+      return this.queryLoki(query, startISOString, endISOString);
+    }
+    async queryLoki(query: string, start: string, end: string): Promise<any> {
+      const url = new URL(`${this.lokiUrl}/loki/api/v1/query_range`);
+      url.searchParams.append('query', query);
+      url.searchParams.append('start', start);
+      url.searchParams.append('end', end);
+      const authHeader = 'Basic ' + btoa(`${this.user}:${this.lokiApiKey}`);
+  
+      const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: authHeader,
+        },
+      });
+  
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Error querying Loki: ${response.status} ${response.statusText} - ${errorText}`,
+        );
+      }
+      //https://grafana.com/docs/loki/latest/reference/loki-http-api/#query-logs-within-a-range-of-time
+      return response.json();
+    }
+  }