@teamkeel/functions-runtime 0.317.0 → 0.318.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.317.0",
+  "version": "0.318.1",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "src/index.js",
   "scripts": {

package/src/handleRequest.js

@@ -14,7 +14,7 @@ const { PROTO_ACTION_TYPES } = require("./consts");
 
 const { errorToJSONRPCResponse, RuntimeErrors } = require("./errors");
 const opentelemetry = require("@opentelemetry/api");
-const { serviceName } = require("./tracing");
+const { getTracer } = require("./tracing");
 
 // Generic handler function that is agnostic to runtime environment (local or lambda)
 // to execute a custom function based on the contents of a jsonrpc-2.0 payload object.
@@ -25,8 +25,7 @@ async function handleRequest(request, config) {
     // "?." is so we don't have to provide this field on tests
     request.meta?.tracing
   );
-  const tracer = opentelemetry.trace.getTracer(serviceName);
-  let span = tracer.startSpan(
+  let span = getTracer().startSpan(
     `Function/${request.method}`,
     { attributes: {} },
     activeContext
@@ -68,17 +67,19 @@ async function handleRequest(request, config) {
     // This is useful for permissions where we want to only proceed with database writes if all permission rules
     // have been validated.
     const result = await db.transaction().execute(async (transaction) => {
-      const ctx = createContextAPI(request.meta);
+      const ctx = createContextAPI({
+        responseHeaders: headers,
+        meta: request.meta,
+      });
       const api = createFunctionAPI({
         meta: request.meta,
-        headers,
         db: transaction,
       });
 
       const customFunction = functions[request.method];
 
       // Call the user's custom function!
-      const fnResult = await customFunction(request.params, api, ctx);
+      const fnResult = await customFunction(ctx, request.params, api);
 
       // api.permissions maintains an internal state of whether the current operation has been *explicitly* permitted/denied by the user in the course of their custom function, or if execution has already been permitted by a role based permission (evaluated in the main runtime).
       // we need to check that the final state is permitted or unpermitted. if it's not, then it means that the user has taken no explicit action to permit/deny

package/src/handleRequest.test.js

@@ -15,7 +15,7 @@ process.env.KEEL_DB_CONN = `postgresql://postgres:postgres@localhost:5432/functi
 test("when the custom function returns expected value", async () => {
   const config = {
     functions: {
-      createPost: async (inputs, api, ctx) => {
+      createPost: async (ctx, inputs, api) => {
         api.permissions.allow();
         return {
           title: "a post",
@@ -26,7 +26,7 @@ test("when the custom function returns expected value", async () => {
     actionTypes: {
       createPost: PROTO_ACTION_TYPES.CREATE,
     },
-    createFunctionAPI: ({ headers, db }) => {
+    createFunctionAPI: ({ db }) => {
       return {
         permissions: new Permissions(),
       };
@@ -52,7 +52,7 @@ test("when the custom function returns expected value", async () => {
 test("when the custom function doesnt return a value", async () => {
   const config = {
     functions: {
-      createPost: async (inputs, api, ctx) => {
+      createPost: async (ctx, inputs, api) => {
         api.permissions.allow();
       },
     },
@@ -60,7 +60,7 @@ test("when the custom function doesnt return a value", async () => {
     actionTypes: {
       createPost: PROTO_ACTION_TYPES.CREATE,
     },
-    createFunctionAPI: ({ headers, db }) => {
+    createFunctionAPI: ({ db }) => {
       return {
         permissions: new Permissions(),
       };
@@ -83,12 +83,12 @@ test("when the custom function doesnt return a value", async () => {
 test("when there is no matching function for the path", async () => {
   const config = {
     functions: {
-      createPost: async (inputs, api, ctx) => {},
+      createPost: async (ctx, inputs, api) => {},
     },
     actionTypes: {
       createPost: PROTO_ACTION_TYPES.CREATE,
     },
-    createFunctionAPI: ({ headers, db }) => {
+    createFunctionAPI: ({ db }) => {
       return {
         permissions: new Permissions(),
       };
@@ -111,7 +111,7 @@ test("when there is no matching function for the path", async () => {
 test("when there is an unexpected error in the custom function", async () => {
   const config = {
     functions: {
-      createPost: async (inputs, api, ctx) => {
+      createPost: async (ctx, inputs, api) => {
         api.permissions.allow();
 
         throw new Error("oopsie daisy");
@@ -120,7 +120,7 @@ test("when there is an unexpected error in the custom function", async () => {
     actionTypes: {
       createPost: PROTO_ACTION_TYPES.CREATE,
     },
-    createFunctionAPI: ({ headers, db }) => {
+    createFunctionAPI: ({ db }) => {
       return {
         permissions: new Permissions(),
       };
@@ -143,7 +143,7 @@ test("when there is an unexpected error in the custom function", async () => {
 test("when a role based permission has already been granted by the main runtime", async () => {
   const config = {
     functions: {
-      createPost: async (inputs, api, ctx) => {
+      createPost: async (ctx, inputs, api) => {
         return {
           title: inputs.title,
         };
@@ -152,7 +152,7 @@ test("when a role based permission has already been granted by the main runtime"
     actionTypes: {
       createPost: PROTO_ACTION_TYPES.CREATE,
     },
-    createFunctionAPI: ({ headers, db }) => {
+    createFunctionAPI: ({ db }) => {
       return {
         permissions: new Permissions({ status: "granted", reason: "role" }),
       };
@@ -177,16 +177,15 @@ test("when a role based permission has already been granted by the main runtime"
 test("when there is an unexpected object thrown in the custom function", async () => {
   const config = {
     functions: {
-      createPost: async (inputs, api, ctx) => {
+      createPost: async (ctx, inputs, api) => {
         api.permissions.allow();
-
         throw { err: "oopsie daisy" };
       },
     },
     actionTypes: {
       createPost: PROTO_ACTION_TYPES.CREATE,
     },
-    createFunctionAPI: ({ headers, db }) => {
+    createFunctionAPI: ({ db }) => {
       return {
         permissions: new Permissions(),
       };
@@ -242,14 +241,14 @@ describe("ModelAPI error handling", () => {
     functionConfig = {
       permissions: {},
       functions: {
-        createPost: async (inputs, api, ctx) => {
+        createPost: async (ctx, inputs, api) => {
           api.permissions.allow();
 
           const post = await api.models.post.create(inputs);
 
           return post;
         },
-        deletePost: async (inputs, api, ctx) => {
+        deletePost: async (ctx, inputs, api) => {
           api.permissions.allow();
 
           const deleted = await api.models.post.delete(inputs);
@@ -257,7 +256,7 @@ describe("ModelAPI error handling", () => {
           return deleted;
         },
       },
-      createFunctionAPI: ({ headers, db }) => ({
+      createFunctionAPI: ({ db }) => ({
         permissions: new Permissions(),
         models: {
           post: new ModelAPI(

package/src/index.d.ts

@@ -52,10 +52,15 @@ export type TimestampQueryInput = {
 
 export type ContextAPI = {
   headers: RequestHeaders;
+  response: Response;
   isAuthenticated: boolean;
   now(): Date;
 };
 
+export type Response = {
+  headers: Headers;
+};
+
 export type PageInfo = {
   startCursor: string;
   endCursor: string;

package/src/tracing.js

@@ -1,11 +1,7 @@
 const opentelemetry = require("@opentelemetry/api");
 
-const serviceName = "customerCustomFunctions";
-
 function withSpan(name, fn) {
-  const tracer = opentelemetry.trace.getTracer(serviceName);
-
-  return tracer.startActiveSpan(name, async (span) => {
+  return getTracer().startActiveSpan(name, async (span) => {
     try {
       // await the thing (this means we can use try/catch)
       return await fn(span);
@@ -25,7 +21,38 @@ function withSpan(name, fn) {
   });
 }
 
+function init() {
+  if (!globalThis.fetch.patched) {
+    const originalFetch = globalThis.fetch;
+
+    globalThis.fetch = async (...args) => {
+      return withSpan("fetch", async (span) => {
+        const url = new URL(
+          args[0] instanceof Request ? args[0].url : String(args[0])
+        );
+        span.setAttribute("http.url", url.toString());
+        const scheme = url.protocol.replace(":", "");
+        span.setAttribute("http.scheme", scheme);
+
+        const options = args[0] instanceof Request ? args[0] : args[1] || {};
+        const method = (options.method || "GET").toUpperCase();
+        span.setAttribute("http.method", method);
+
+        const res = await originalFetch(...args);
+        span.setAttribute("http.status", res.status);
+        span.setAttribute("http.status_text", res.statusText);
+      });
+    };
+    globalThis.fetch.patched = true;
+  }
+}
+
+function getTracer() {
+  return opentelemetry.trace.getTracer("functions");
+}
+
 module.exports = {
-  serviceName,
+  getTracer,
   withSpan,
+  init,
 };

package/src/tracing.test.js

@@ -21,6 +21,7 @@ provider.addSpanProcessor({
 provider.register();
 
 beforeEach(() => {
+  tracing.init();
   spanEvents = [];
 });
 
@@ -54,3 +55,64 @@ test("withSpan on error", async () => {
     });
   }
 });
+
+test("fetch - 200", async () => {
+  await fetch("http://example.com");
+
+  expect(spanEvents.map((e) => e.event)).toEqual(["onStart", "onEnd"]);
+  expect(spanEvents.pop().span.attributes).toEqual({
+    "http.url": "http://example.com/",
+    "http.scheme": "http",
+    "http.method": "GET",
+    "http.status": 200,
+    "http.status_text": "OK",
+  });
+});
+
+test("fetch - 404", async () => {
+  await fetch("http://example.com/movies.json");
+
+  expect(spanEvents.map((e) => e.event)).toEqual(["onStart", "onEnd"]);
+  expect(spanEvents.pop().span.attributes).toEqual({
+    "http.url": "http://example.com/movies.json",
+    "http.scheme": "http",
+    "http.method": "GET",
+    "http.status": 404,
+    "http.status_text": "Not Found",
+  });
+});
+
+test("fetch - invalid URL", async () => {
+  try {
+    await fetch({});
+  } catch (err) {
+    expect(err.message).toEqual("Invalid URL");
+  }
+
+  expect(spanEvents.map((e) => e.event)).toEqual(["onStart", "onEnd"]);
+
+  const span = spanEvents.pop().span;
+  expect(spanEvents.pop().span.attributes).toEqual({});
+  expect(span.events[0].name).toEqual("exception");
+  expect.assertions(4);
+});
+
+test("fetch - ENOTFOUND", async () => {
+  try {
+    await fetch("http://qpwoeuthnvksnvnsanrurvnc.com");
+  } catch (err) {
+    expect(err.message).toEqual("fetch failed");
+    expect(err.cause.code).toEqual("ENOTFOUND");
+  }
+
+  expect(spanEvents.map((e) => e.event)).toEqual(["onStart", "onEnd"]);
+
+  const span = spanEvents.pop().span;
+  expect(span.attributes).toEqual({
+    "http.method": "GET",
+    "http.scheme": "http",
+    "http.url": "http://qpwoeuthnvksnvnsanrurvnc.com/",
+  });
+  expect(span.events[0].name).toEqual("exception");
+  expect.assertions(5);
+});