add analytics to the gateway

jest.setup.ts

@@ -1,4 +1 @@
-import { TextEncoder, TextDecoder } from 'util';
-
-global.TextEncoder = TextEncoder;
-global.TextDecoder = TextDecoder as any;
+// any jest related setup here

package.json

@@ -53,11 +53,12 @@
     }
   ],
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20230214.0",
+    "@cloudflare/workers-types": "^4.20240117.0",
     "@ensdomains/ens-contracts": "^0.0.21",
     "@types/chai": "^4.3.4",
     "@types/chai-as-promised": "^7.1.5",
-    "@types/dns-packet": "^5.2.4",
+    "@types/dns-packet": "^5.6.4",
+    "@types/express": "^4.17.21",
     "@types/supertest": "^2.0.11",
     "bundlesize2": "^0.0.31",
     "chai": "^4.3.7",
@@ -73,8 +74,9 @@
   },
   "dependencies": {
     "@chainlink/ccip-read-server": "^0.2.1",
-    "@ensdomains/ccip-read-cf-worker": "^0.0.1",
+    "@ensdomains/ccip-read-cf-worker": "^0.0.3",
     "@ensdomains/dnsprovejs": "^0.4.1",
+    "@ensdomains/server-analytics": "^0.0.1-alpha.2",
     "dotenv": "^16.0.3",
     "ethers": "^5.7.2",
     "node-fetch": "2.6.1"

src/app.ts

@@ -2,13 +2,23 @@ import { DNSProver } from '@ensdomains/dnsprovejs';
 import { ethers } from 'ethers';
 import * as packet from 'dns-packet';
 import * as qTypes from 'dns-packet/types';
+import { serializeError } from './utils';
 
 export function makeApp(
   sendQuery: ConstructorParameters<typeof DNSProver>[0],
   path: string,
-  Server: any
+  Server: any,
+  trackEvent?: Function
 ) {
   const prover = new DNSProver(sendQuery);
+  const emptyRRSet = [
+    [
+      {
+        rrset: [],
+        sig: [],
+      },
+    ],
+  ];
 
   const server = new Server();
   const abi = [
@@ -19,20 +29,56 @@ export function makeApp(
       type: 'resolve',
       func: async (args: ethers.utils.Result) => {
         const [name, qtype] = args;
-        const decodedName = packet.name.decode(
+        const decodedName = (packet as any).name.decode(
           Buffer.from(name.slice(2), 'hex')
         );
-        const result = await prover.queryWithProof(
-          qTypes.toString(qtype),
-          decodedName
-        );
-        const ret = Array.prototype
-          .concat(result.proofs, [result.answer])
-          .map(entry => ({
-            rrset: entry.toWire(),
-            sig: entry.signature.data.signature,
-          }));
-        return [ret];
+
+        if (
+          decodedName.split('.').length < 2 ||
+          decodedName.startsWith('.') ||
+          decodedName.endsWith('.')
+        ) {
+          return emptyRRSet;
+        }
+
+        if (trackEvent) {
+          trackEvent(
+            'resolve',
+            {
+              props: { name: decodedName, qtype: qTypes.toString(qtype) },
+            },
+            true
+          );
+        }
+
+        try {
+          const result = await prover.queryWithProof(
+            qTypes.toString(qtype),
+            decodedName
+          );
+          if (!result) {
+            return emptyRRSet;
+          }
+          const ret = Array.prototype
+            .concat(result.proofs, [result.answer])
+            .map(entry => ({
+              rrset: entry.toWire(),
+              sig: entry.signature.data.signature,
+            }));
+          return [ret];
+        } catch (error) {
+          if (trackEvent) {
+            trackEvent(
+              'error',
+              {
+                props: { name: decodedName, message: serializeError(error) },
+              },
+              true
+            );
+          }
+
+          return emptyRRSet;
+        }
       },
     },
   ]);

src/utils.ts

@@ -0,0 +1,13 @@
+export function serializeError(error: any) {
+  if (error instanceof Error) {
+    const errorObject = {
+      ...(error.message && {
+        message: JSON.stringify(error.message),
+      }),
+      ...(error.stack && { stack: error.stack }),
+    };
+    return JSON.stringify(errorObject);
+  } else {
+    return JSON.stringify(error);
+  }
+}

src/worker.ts

@@ -1,17 +1,67 @@
+import {
+  Request as CFWRequest,
+  ExecutionContext,
+} from '@cloudflare/workers-types';
 import { Server } from '@ensdomains/ccip-read-cf-worker';
+import { Tracker } from '@ensdomains/server-analytics';
 import { dohQuery } from '@ensdomains/dnsprovejs';
 import { makeApp } from './app';
 
-const routeHandler = (env: any) => {
+interface ENV {
+  DOH_GATEWAY_URL: string;
+  PLAUSIBLE_BASE_URL: string;
+}
+
+const tracker = new Tracker('ccip-read-dns-worker.ens-cf.workers.dev', {
+  enableLogging: true,
+});
+
+const routeHandler = (env: ENV, trackEvent?: Function) => {
   const { DOH_GATEWAY_URL } = env;
-  const app = makeApp(dohQuery(DOH_GATEWAY_URL as string), '/', Server);
+  const app = makeApp(
+    dohQuery(DOH_GATEWAY_URL as string),
+    '/',
+    Server,
+    trackEvent
+  );
   console.log(`Serving with DoH Resolver ${DOH_GATEWAY_URL}`);
   return app;
 };
 
+const logResult = async (request: CFWRequest, result: Response) => {
+  if (!result.body) {
+    return result;
+  }
+  const [streamForLog, streamForResult] = result.body.tee();
+  try {
+    const resultForLog: { data: string } = await new Response(
+      streamForLog
+    ).json();
+
+    await tracker.trackEvent(
+      request,
+      'result',
+      { props: { result: resultForLog.data.substring(0, 200) } },
+      true
+    );
+  } catch (error) {
+    console.log('error logging result:', error);
+  }
+  return new Response(streamForResult, result);
+};
+
 module.exports = {
-  fetch: async function(request: Request, env: any, _context: any) {
-    const router = routeHandler(env);
-    return await router.handle(request);
+  fetch: async function(
+    request: CFWRequest,
+    env: ENV,
+    _context: ExecutionContext
+  ) {
+    if (env.PLAUSIBLE_BASE_URL) {
+      tracker.apiEndpoint = env.PLAUSIBLE_BASE_URL;
+    }
+    await tracker.trackEvent(request, 'request', {}, true);
+    await tracker.trackPageview(request, {}, true);
+    const router = routeHandler(env, tracker.trackEvent.bind(tracker, request));
+    return router.handle(request).then(logResult.bind(this, request));
   },
 };

tsconfig.json

@@ -4,6 +4,7 @@
   "compilerOptions": {
     "module": "esnext",
     "lib": ["dom", "esnext"],
+    "types": ["jest", "@cloudflare/workers-types"],
     "importHelpers": true,
     // output .d.ts declaration files for consumers
     "declaration": true,