@teamkeel/functions-runtime 0.313.7 → 0.314.0

package/src/ModelAPI.js

@@ -4,6 +4,7 @@ const { QueryContext } = require("./QueryContext");
 const { applyWhereConditions } = require("./applyWhereConditions");
 const { applyJoins } = require("./applyJoins");
 const { camelCaseObject, snakeCaseObject } = require("./casing");
+const tracing = require("./tracing");
 
 /**
  * RelationshipConfig is a simple representation of a model field that
@@ -48,7 +49,7 @@ class ModelAPI {
   async create(values) {
     try {
       const defaults = this._defaultValues();
-      const row = await this._db
+      const query = this._db
         .insertInto(this._tableName)
         .values(
           snakeCaseObject({
@@ -56,8 +57,15 @@ class ModelAPI {
             ...values,
           })
         )
-        .returningAll()
-        .executeTakeFirstOrThrow();
+        .returningAll();
+      const sql = query.compile().sql;
+      const row = await tracing.withSpan(
+        `${this._tableName}.create`,
+        (span) => {
+          span.setAttribute("sql", sql);
+          return query.executeTakeFirstOrThrow();
+        }
+      );
 
       return camelCaseObject(row);
     } catch (e) {
@@ -76,7 +84,11 @@ class ModelAPI {
     builder = applyJoins(context, builder, where);
     builder = applyWhereConditions(context, builder, where);
 
-    const row = await builder.executeTakeFirst();
+    const sql = builder.compile().sql;
+    const row = await tracing.withSpan(`${this._tableName}.findOne`, (span) => {
+      span.setAttribute("sql", sql);
+      return builder.executeTakeFirst();
+    });
     if (!row) {
       return null;
     }
@@ -94,8 +106,16 @@ class ModelAPI {
 
     builder = applyJoins(context, builder, where);
     builder = applyWhereConditions(context, builder, where);
-
-    const rows = await builder.orderBy("id").execute();
+    const query = builder.orderBy("id");
+
+    const sql = query.compile().sql;
+    const rows = await tracing.withSpan(
+      `${this._tableName}.findMany`,
+      (span) => {
+        span.setAttribute("sql", sql);
+        return builder.execute();
+      }
+    );
     return rows.map((x) => camelCaseObject(x));
   }
 
@@ -110,7 +130,14 @@ class ModelAPI {
     builder = applyWhereConditions(context, builder, where);
 
     try {
-      const row = await builder.executeTakeFirstOrThrow();
+      const sql = builder.compile().sql;
+      const row = await tracing.withSpan(
+        `${this._tableName}.update`,
+        (span) => {
+          span.setAttribute("sql", sql);
+          return builder.executeTakeFirstOrThrow();
+        }
+      );
 
       return camelCaseObject(row);
     } catch (e) {
@@ -127,7 +154,14 @@ class ModelAPI {
     builder = applyWhereConditions(context, builder, where);
 
     try {
-      const row = await builder.executeTakeFirstOrThrow();
+      const sql = builder.compile().sql;
+      const row = await tracing.withSpan(
+        `${this._tableName}.delete`,
+        (span) => {
+          span.setAttribute("sql", sql);
+          return builder.executeTakeFirstOrThrow();
+        }
+      );
 
       return row.id;
     } catch (e) {

package/src/QueryBuilder.js

@@ -1,6 +1,7 @@
 const { applyWhereConditions } = require("./applyWhereConditions");
 const { applyJoins } = require("./applyJoins");
 const { camelCaseObject } = require("./casing");
+const tracing = require("./tracing");
 
 class QueryBuilder {
   /**
@@ -34,7 +35,12 @@ class QueryBuilder {
   }
 
   async findMany() {
-    const rows = await this._db.orderBy("id").execute();
+    const query = this._db.orderBy("id");
+    const sql = query.compile().sql;
+    const rows = await tracing.withSpan(`query`, (span) => {
+      span.setAttribute("sql", sql);
+      return query.execute();
+    });
     return rows.map((x) => camelCaseObject(x));
   }
 }

package/src/tracing.js

@@ -0,0 +1,30 @@
+const opentelemetry = require("@opentelemetry/api");
+
+const serviceName = "customerCustomFunctions";
+
+const tracer = opentelemetry.trace.getTracer(serviceName);
+
+function withSpan(name, fn) {
+  return tracer.startActiveSpan(name, async (span) => {
+    try {
+      // await the thing (this means we can use try/catch)
+      return await fn(span);
+    } catch (err) {
+      // record any errors
+      span.recordException(err);
+      span.setStatus({
+        code: opentelemetry.SpanStatusCode.ERROR,
+        message: err.message,
+      });
+      // re-throw the error
+      throw err;
+    } finally {
+      // make sure the span is ended
+      span.end();
+    }
+  });
+}
+
+module.exports = {
+  withSpan,
+};

package/src/tracing.test.js

@@ -0,0 +1,56 @@
+import { expect, test, beforeEach } from "vitest";
+import tracing from "./tracing";
+import { NodeTracerProvider, Span } from "@opentelemetry/sdk-trace-node";
+
+let spanEvents = [];
+const provider = new NodeTracerProvider({});
+provider.addSpanProcessor({
+  forceFlush() {
+    return Promise.resolve();
+  },
+  onStart(span, parentContext) {
+    spanEvents.push({ event: "onStart", span, parentContext });
+  },
+  onEnd(span) {
+    spanEvents.push({ event: "onEnd", span });
+  },
+  shutdown() {
+    return Promise.resolve();
+  },
+});
+provider.register();
+
+beforeEach(() => {
+  spanEvents = [];
+});
+
+test("withSpan span time", async () => {
+  const waitTimeMillis = 100;
+  await tracing.withSpan("name", async () => {
+    await new Promise((resolve) => setTimeout(resolve, waitTimeMillis));
+  });
+
+  expect(spanEvents.map((e) => e.event)).toEqual(["onStart", "onEnd"]);
+  const spanDuration = spanEvents.pop().span._duration.pop();
+  const waitTimeNanos = waitTimeMillis * 1000 * 1000;
+  expect(spanDuration).toBeGreaterThan(waitTimeNanos);
+});
+
+test("withSpan on error", async () => {
+  try {
+    await tracing.withSpan("name", async () => {
+      throw "err";
+    });
+    // previous line should have an error thrown
+    expect(true).toEqual(false);
+  } catch (e) {
+    expect(e).toEqual("err");
+    expect(spanEvents.map((e) => e.event)).toEqual(["onStart", "onEnd"]);
+    const lastSpanEvents = spanEvents.pop().span.events;
+    expect(lastSpanEvents).length(1);
+    expect(lastSpanEvents[0].name).toEqual("exception");
+    expect(lastSpanEvents[0].attributes).toEqual({
+      "exception.message": "err",
+    });
+  }
+});