Adds timings do actor lib (#39)

Signed-off-by: Marcos Candeia <marrcooos@gmail.com>

Author: mcandeia

src/actors/discover.ts

@@ -6,7 +6,6 @@ import {
   type ActorRuntime,
   StdActorRuntime,
 } from "./runtime.ts";
-import { ActorCfRuntime } from "./runtimes/cf/fetcher.ts";
 
 const IS_DENO = getRuntimeKey() === "deno";
 
@@ -20,7 +19,7 @@ export const RuntimeClass: {
   >(
     Actor: TConstructor,
   ) => TConstructor;
-} = IS_DENO ? StdActorRuntime : ActorCfRuntime;
+} = IS_DENO ? StdActorRuntime : StdActorRuntime;
 
 export const RUNTIME = new RuntimeClass();
 export const Actor = RuntimeClass.Actor;

src/actors/storage/denoKv.ts

@@ -40,7 +40,7 @@ function assertIsDefined<V>(
 ): asserts v is NonNullable<V> {
   const isDefined = v !== null && typeof v !== "undefined";
   if (!isDefined) {
-    throw new Error(`Expected 'v' to be defined, but received ${v}`);
+    throw new Error(`Expected 'DenoKv' to be defined, but received ${v}`);
   }
 }
 interface AtomicOp {
@@ -58,7 +58,7 @@ export class DenoKvActorStorage implements ActorStorage {
   constructor(protected options: StorageOptions) {
     assertIsDefined(kv);
     this.kv = kv;
-    this.kvOrTransaction = options.atomicOp?.kv ?? kv;
+    this.kvOrTransaction = options.atomicOp?.kv ?? this.kv;
     this.atomicOp = options.atomicOp;
   }
   private warnAlams() {

src/actors/stub/stub.server.ts

@@ -5,6 +5,7 @@ import {
   EVENT_STREAM_RESPONSE_HEADER,
   isEventStreamResponse,
 } from "../stream.ts";
+import { createServerTimings, type ServerTimingsBuilder } from "../timings.ts";
 import { serializeUint8Array } from "../util/buffers.ts";
 import { isUpgrade, makeWebSocket } from "../util/channels/channel.ts";
 import { invokeNameAndMethod } from "../util/locator.ts";
@@ -50,6 +51,7 @@ export interface InvokeMiddlewareOptions {
   args: unknown[];
   metadata: unknown;
   request: Request;
+  timings: ServerTimingsBuilder;
 }
 
 export type InvokeMiddleware = (
@@ -67,11 +69,16 @@ const hasInvokeMiddleware = (
 
 const invokeResponse = async (
   url: URL,
-  options: InvokeOptions<any> & { request: Request },
+  options: InvokeOptions<any> & {
+    request: Request;
+    timings: ServerTimingsBuilder;
+  },
 ): Promise<Response> => {
   try {
     const { request: req } = options;
+    const invokeTiming = options.timings.start("invoke");
     const res = await invoke(options);
+    invokeTiming.end();
     if (isUpgrade(res) && req.headers.get("upgrade") === "websocket") {
       const { socket, response } = upgradeWebSocket(req);
       const chunkSize = url.searchParams.get(STUB_MAX_CHUNK_SIZE_QS_NAME);
@@ -179,18 +186,21 @@ export const server = <T extends object>(
   instanceCreator: (name: string, req: Request) => Promise<T>,
 ): (req: Request) => Promise<Response> => {
   return async (req: Request) => {
+    const timings = createServerTimings();
+    using _ = timings.start("actor-entire-request");
     const url = new URL(req.url);
     const locator = invokeNameAndMethod(url.pathname);
 
     if (!locator) {
       return new Response(null, { status: 404 });
     }
 
+    const instanceCreatorTiming = timings.start("actor-instance-creator");
     const objInstance = await instanceCreator(
       locator.name,
       req,
     );
-
+    instanceCreatorTiming.end();
     const { name: stubName, method: stubMethod } = locator;
     if (!stubMethod || !stubName) {
       return new Response(
@@ -227,18 +237,36 @@ export const server = <T extends object>(
       metadata = parsedArgs.metadata;
     }
     const next = (mid: InvokeMiddlewareOptions) => {
+      const invokeResponseTiming = mid.timings.start("invoke-response");
       return invokeResponse(url, {
         instance: objInstance,
         stubName,
         methodName: mid.method,
         args: mid.args,
         metadata: mid.metadata,
         request: mid.request,
+        timings: mid.timings,
+      }).finally(() => invokeResponseTiming.end()).then((res) => {
+        try {
+          res.headers.set("server-timing", mid.timings.printTimings());
+        } catch {
+          // some headers are immutable
+        }
+        return res;
       });
     };
-    const options = { args, metadata, request: req, method: stubMethod };
+    const options = {
+      args,
+      metadata,
+      request: req,
+      method: stubMethod,
+      timings,
+    };
     if (hasInvokeMiddleware(objInstance)) {
-      return objInstance.onBeforeInvoke(options, next);
+      const onBeforeInvokeTiming = timings.start("on-before-invoke");
+      return objInstance.onBeforeInvoke(options, next).finally(() =>
+        onBeforeInvokeTiming.end()
+      );
     }
     return next(options);
   };

src/actors/timings.ts

@@ -0,0 +1,64 @@
+export interface Timing {
+  name: string;
+  desc?: string;
+  start: number;
+  end?: number;
+}
+
+export interface ServerTimingsBuilder {
+  get: () => readonly Timing[];
+  start: (
+    name: string,
+    desc?: string,
+    start?: number,
+  ) => {
+    [Symbol.dispose]: () => void;
+    end: () => void;
+    setDesc: (desc: string | undefined) => void;
+    name: () => string;
+  };
+  printTimings: () => string;
+}
+
+export function createServerTimings(): ServerTimingsBuilder {
+  const timings: Timing[] = [];
+
+  const start = (name: string, desc?: string, start?: number) => {
+    const t: Timing = { name, desc, start: start || performance.now() };
+
+    timings.push(t);
+
+    return {
+      [Symbol.dispose]: () => {
+        t.end = performance.now();
+      },
+      end: () => {
+        t.end = performance.now();
+      },
+      setDesc: (desc: string | undefined) => {
+        t.desc = desc;
+      },
+      name: () => t.name,
+    };
+  };
+
+  const printTimings = () =>
+    timings
+      .map(({ name, desc, start, end }) => {
+        if (!end || !name) return;
+
+        return `${encodeURIComponent(name)}${desc ? `;desc=${desc}` : ""};dur=${
+          (end - start).toFixed(0)
+        }`;
+      })
+      .filter(Boolean)
+      .join(", ");
+
+  const get = (): readonly Timing[] => timings;
+
+  return {
+    get,
+    start,
+    printTimings,
+  };
+}