feat: instrument slonik.connection.create

Author: gajus

.changeset/smart-crews-prove.md

@@ -0,0 +1,5 @@
+---
+"slonik": minor
+---
+
+instrument slonik.connection.create

packages/slonik/src/factories/createConnection.ts

@@ -131,81 +131,98 @@ export const createConnection = async (
     }
   }
 
-  const connection = await establishConnection(
-    parentLog,
-    pool,
-    clientConfiguration.connectionRetryLimit,
-  );
-
-  return raceError(connection, async () => {
-    const { connectionId } = getPoolClientState(connection);
-
-    const connectionLog = parentLog.child({
-      connectionId,
-    });
-
-    const connectionContext = {
-      connectionId,
-      connectionType,
-      log: connectionLog,
-      poolId,
-    };
+  return await tracer.startActiveSpan(
+    'slonik.connection.create',
+    async (span) => {
+      try {
+        const connection = await establishConnection(
+          parentLog,
+          pool,
+          clientConfiguration.connectionRetryLimit,
+        );
+
+        return raceError(connection, async () => {
+          const { connectionId } = getPoolClientState(connection);
+
+          const connectionLog = parentLog.child({
+            connectionId,
+          });
+
+          const connectionContext = {
+            connectionId,
+            connectionType,
+            log: connectionLog,
+            poolId,
+          };
+
+          const boundConnection = bindPoolConnection(
+            connectionLog,
+            connection,
+            clientConfiguration,
+          );
 
-    const boundConnection = bindPoolConnection(
-      connectionLog,
-      connection,
-      clientConfiguration,
-    );
+          try {
+            for (const interceptor of clientConfiguration.interceptors) {
+              if (interceptor.afterPoolConnection) {
+                await interceptor.afterPoolConnection(
+                  connectionContext,
+                  boundConnection,
+                );
+              }
+            }
+          } catch (error) {
+            await connection.destroy();
 
-    try {
-      for (const interceptor of clientConfiguration.interceptors) {
-        if (interceptor.afterPoolConnection) {
-          await interceptor.afterPoolConnection(
-            connectionContext,
-            boundConnection,
-          );
-        }
-      }
-    } catch (error) {
-      await connection.destroy();
+            throw error;
+          }
 
-      throw error;
-    }
+          let result;
 
-    let result;
+          try {
+            result = await connectionHandler(
+              connectionLog,
+              connection,
+              boundConnection,
+              clientConfiguration,
+            );
+          } catch (error) {
+            await connection.destroy();
 
-    try {
-      result = await connectionHandler(
-        connectionLog,
-        connection,
-        boundConnection,
-        clientConfiguration,
-      );
-    } catch (error) {
-      await connection.destroy();
+            throw error;
+          }
 
-      throw error;
-    }
+          try {
+            for (const interceptor of clientConfiguration.interceptors) {
+              if (interceptor.beforePoolConnectionRelease) {
+                await interceptor.beforePoolConnectionRelease(
+                  connectionContext,
+                  boundConnection,
+                );
+              }
+            }
+          } catch (error) {
+            await connection.destroy();
 
-    try {
-      for (const interceptor of clientConfiguration.interceptors) {
-        if (interceptor.beforePoolConnectionRelease) {
-          await interceptor.beforePoolConnectionRelease(
-            connectionContext,
-            boundConnection,
-          );
-        }
-      }
-    } catch (error) {
-      await connection.destroy();
+            throw error;
+          }
 
-      throw error;
-    }
+          destroyBoundConnection(boundConnection);
 
-    destroyBoundConnection(boundConnection);
+          await connection.release();
 
-    await connection.release();
+          return result;
+        });
+      } catch (error) {
+        span.recordException(error);
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: String(error),
+        });
 
-    return result;
-  });
+        throw error;
+      } finally {
+        span.end();
+      }
+    },
+  );
 };