feat(js): Support Otel logging (#4981)

Author: shrutip90

genkit-tools/cli/src/utils/manager-utils.ts

@@ -15,6 +15,7 @@
  */
 
 import {
+  LocalFileLogStore,
   LocalFileTraceStore,
   startTelemetryServer,
 } from '@genkit-ai/telemetry-server';
@@ -48,6 +49,10 @@ export async function resolveTelemetryServer(options: {
         storeRoot: options.projectRoot,
         indexRoot: options.projectRoot,
       }),
+      logStore: new LocalFileLogStore({
+        storeRoot: options.projectRoot,
+        indexRoot: options.projectRoot,
+      }),
       corsOrigin: options.corsOrigin,
     });
   }

genkit-tools/common/src/manager/manager.ts

@@ -135,6 +135,40 @@ export abstract class BaseRuntimeManager {
     return apis.ListTracesResponseSchema.parse(response.data);
   }
 
+  /**
+   * Retrieves all logs
+   */
+  async listLogs(input: apis.ListLogsRequest): Promise<apis.ListLogsResponse> {
+    const { limit, continuationToken, filter } = input;
+
+    let url = `${this.telemetryServerUrl}/api/logs`;
+    if (filter?.traceId) {
+      url = `${this.telemetryServerUrl}/api/traces/${filter.traceId}/logs`;
+      if (filter.spanId) {
+        url = `${this.telemetryServerUrl}/api/traces/${filter.traceId}/spans/${filter.spanId}/logs`;
+      }
+    }
+
+    let query = '';
+    if (limit) {
+      query += `limit=${limit}`;
+    }
+    if (continuationToken) {
+      if (query !== '') query += '&';
+      query += `continuationToken=${continuationToken}`;
+    }
+
+    const fullUrl = query !== '' ? `${url}?${query}` : url;
+
+    const response = await axios
+      .get(fullUrl)
+      .catch((err) =>
+        this.httpErrorHandler(err, `Error listing logs for url='${fullUrl}'.`)
+      );
+
+    return apis.ListLogsResponseSchema.parse(response.data);
+  }
+
   /**
    * Retrieves a trace for a given ID.
    */

genkit-tools/common/src/server/router.ts

@@ -160,6 +160,13 @@ export const TOOLS_SERVER_ROUTER = (manager: BaseRuntimeManager) =>
         return manager.listTraces(input);
       }),
 
+    /** Retrieves all logs. */
+    listLogs: loggedProcedure
+      .input(apis.ListLogsRequestSchema)
+      .query(async ({ input }) => {
+        return manager.listLogs(input);
+      }),
+
     /** Retrieves a trace for a given ID. */
     getTrace: loggedProcedure
       .input(apis.GetTraceRequestSchema)

genkit-tools/common/src/types/apis.ts

@@ -21,6 +21,7 @@ import {
   EvalRunKeySchema,
   InferenceDatasetSchema,
 } from './eval';
+import { LogRecordSchema } from './log';
 import {
   GenerationCommonConfigSchema,
   MessageSchema,
@@ -63,6 +64,28 @@ export const ListTracesResponseSchema = z.object({
 
 export type ListTracesResponse = z.infer<typeof ListTracesResponseSchema>;
 
+export const LogQueryFilterSchema = z.object({
+  traceId: z.string().optional(),
+  spanId: z.string().optional(),
+});
+
+export type LogQueryFilter = z.infer<typeof LogQueryFilterSchema>;
+
+export const ListLogsRequestSchema = z.object({
+  limit: z.number().optional(),
+  continuationToken: z.string().optional(),
+  filter: LogQueryFilterSchema.optional(),
+});
+
+export type ListLogsRequest = z.infer<typeof ListLogsRequestSchema>;
+
+export const ListLogsResponseSchema = z.object({
+  logs: z.array(LogRecordSchema),
+  continuationToken: z.string().optional(),
+});
+
+export type ListLogsResponse = z.infer<typeof ListLogsResponseSchema>;
+
 export const GetTraceRequestSchema = z.object({
   traceId: z.string().describe('ID of the trace.'),
 });

genkit-tools/common/src/types/index.ts

@@ -23,6 +23,7 @@ export * from './document';
 export * from './env';
 export * from './eval';
 export * from './evaluator';
+export * from './log';
 export * from './middleware';
 export * from './model';
 export * from './prompt';

genkit-tools/common/src/types/log.ts

@@ -0,0 +1,66 @@
+/**
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { extendZodWithOpenApi } from '@asteasolutions/zod-to-openapi';
+import * as z from 'zod';
+
+import { InstrumentationLibrarySchema } from './trace';
+
+extendZodWithOpenApi(z);
+
+/**
+ * Zod schema for log record data.
+ */
+export const LogRecordSchema = z
+  .object({
+    logId: z.string(), // Server-generated if omitted
+    traceId: z.string().optional(),
+    spanId: z.string().optional(),
+    timestamp: z
+      .number()
+      .describe('log recorded time in milliseconds since the epoch'),
+    severityNumber: z.number().optional(),
+    severityText: z.string().optional(),
+    body: z.unknown().optional(), // Represents any value: string, number, boolean, array, or object
+    attributes: z.record(z.string(), z.unknown()).optional(),
+    instrumentationLibrary: InstrumentationLibrarySchema.optional(),
+  })
+  .openapi('LogRecordData');
+
+export type LogRecordData = z.infer<typeof LogRecordSchema>;
+
+/**
+ * Log query parameters.
+ */
+export const LogQuerySchema = z.object({
+  limit: z.coerce.number().optional(),
+  continuationToken: z.string().optional(),
+  traceId: z.string().optional(),
+  spanId: z.string().optional(),
+});
+
+export type LogQuery = z.infer<typeof LogQuerySchema>;
+
+export interface LogQueryResponse {
+  logs: LogRecordData[];
+  continuationToken?: string;
+}
+
+export interface LogStore {
+  init(): Promise<void>;
+  save(logs: LogRecordData[]): Promise<void>;
+  list(query?: LogQuery): Promise<LogQueryResponse>;
+}