sqlite: use diagnostic channel

Author: araujogui

doc/api/sqlite.md

@@ -395,56 +395,6 @@ added:
 This method is used to create SQLite user-defined functions. This method is a
 wrapper around [`sqlite3_create_function_v2()`][].
 
-### `database.setSqlTraceHook(hook)`
-
-<!-- YAML
-added: REPLACEME
--->
-
-* `hook` {Function|null} The trace function to set, or `null` to clear
-  the current hook.
-
-Sets a hook that SQLite invokes for every SQL statement executed against the
-database. The hook receives the expanded SQL string (with bound parameter
-values substituted) as its only argument. If expansion fails, the source SQL
-with unsubstituted placeholders is passed instead.
-
-This method is a wrapper around [`sqlite3_trace_v2()`][].
-
-```cjs
-const { DatabaseSync } = require('node:sqlite');
-const db = new DatabaseSync(':memory:');
-
-db.setSqlTraceHook((sql) => console.log(sql));
-
-db.exec('CREATE TABLE t (x INTEGER)');
-// Logs: CREATE TABLE t (x INTEGER)
-
-const stmt = db.prepare('INSERT INTO t VALUES (?)');
-stmt.run(42);
-// Logs: INSERT INTO t VALUES (42.0)
-
-// Clear the hook
-db.setSqlTraceHook(null);
-```
-
-```mjs
-import { DatabaseSync } from 'node:sqlite';
-const db = new DatabaseSync(':memory:');
-
-db.setSqlTraceHook((sql) => console.log(sql));
-
-db.exec('CREATE TABLE t (x INTEGER)');
-// Logs: CREATE TABLE t (x INTEGER)
-
-const stmt = db.prepare('INSERT INTO t VALUES (?)');
-stmt.run(42);
-// Logs: INSERT INTO t VALUES (42.0)
-
-// Clear the hook
-db.setSqlTraceHook(null);
-```
-
 ### `database.setAuthorizer(callback)`
 
 <!-- YAML
@@ -1331,6 +1281,66 @@ const totalPagesTransferred = await backup(sourceDb, 'backup.db', {
 console.log('Backup completed', totalPagesTransferred);
 ```
 
+## Diagnostics channel
+
+<!-- YAML
+added: REPLACEME
+-->
+
+The `node:sqlite` module publishes SQL trace events on the
+[`diagnostics_channel`][] channel `sqlite.db.query`. This allows subscribers
+to observe every SQL statement executed against any `DatabaseSync` instance
+without modifying the database code itself. Tracing is zero-cost when there
+are no subscribers.
+
+### Channel `sqlite.db.query`
+
+The message published to this channel is a {string} containing the expanded
+SQL with bound parameter values substituted. If expansion fails, the source
+SQL with unsubstituted placeholders is used instead.
+
+```cjs
+const dc = require('node:diagnostics_channel');
+const { DatabaseSync } = require('node:sqlite');
+
+function onQuery(sql) {
+  console.log(sql);
+}
+
+dc.subscribe('sqlite.db.query', onQuery);
+
+const db = new DatabaseSync(':memory:');
+db.exec('CREATE TABLE t (x INTEGER)');
+// Logs: CREATE TABLE t (x INTEGER)
+
+const stmt = db.prepare('INSERT INTO t VALUES (?)');
+stmt.run(42);
+// Logs: INSERT INTO t VALUES (42.0)
+
+dc.unsubscribe('sqlite.db.query', onQuery);
+```
+
+```mjs
+import dc from 'node:diagnostics_channel';
+import { DatabaseSync } from 'node:sqlite';
+
+function onQuery(sql) {
+  console.log(sql);
+}
+
+dc.subscribe('sqlite.db.query', onQuery);
+
+const db = new DatabaseSync(':memory:');
+db.exec('CREATE TABLE t (x INTEGER)');
+// Logs: CREATE TABLE t (x INTEGER)
+
+const stmt = db.prepare('INSERT INTO t VALUES (?)');
+stmt.run(42);
+// Logs: INSERT INTO t VALUES (42.0)
+
+dc.unsubscribe('sqlite.db.query', onQuery);
+```
+
 ## `sqlite.constants`
 
 <!-- YAML
@@ -1596,6 +1606,7 @@ callback function to indicate what type of operation is being authorized.
 [`database.applyChangeset()`]: #databaseapplychangesetchangeset-options
 [`database.createTagStore()`]: #databasecreatetagstoremaxsize
 [`database.setAuthorizer()`]: #databasesetauthorizercallback
+[`diagnostics_channel`]: diagnostics_channel.md
 [`sqlite3_backup_finish()`]: https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupfinish
 [`sqlite3_backup_init()`]: https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupinit
 [`sqlite3_backup_step()`]: https://www.sqlite.org/c3ref/backup_finish.html#sqlite3backupstep
@@ -1617,7 +1628,6 @@ callback function to indicate what type of operation is being authorized.
 [`sqlite3_prepare_v2()`]: https://www.sqlite.org/c3ref/prepare.html
 [`sqlite3_set_authorizer()`]: https://sqlite.org/c3ref/set_authorizer.html
 [`sqlite3_sql()`]: https://www.sqlite.org/c3ref/expanded_sql.html
-[`sqlite3_trace_v2()`]: https://www.sqlite.org/c3ref/trace_v2.html
 [`sqlite3changeset_apply()`]: https://www.sqlite.org/session/sqlite3changeset_apply.html
 [`sqlite3session_attach()`]: https://www.sqlite.org/session/sqlite3session_attach.html
 [`sqlite3session_changeset()`]: https://www.sqlite.org/session/sqlite3session_changeset.html

src/node_sqlite.cc

@@ -5,6 +5,7 @@
 #include "env-inl.h"
 #include "memory_tracker-inl.h"
 #include "node.h"
+#include "node_diagnostics_channel.h"
 #include "node_errors.h"
 #include "node_mem-inl.h"
 #include "node_url.h"
@@ -974,6 +975,8 @@ bool DatabaseSync::Open() {
         env()->isolate(), this, load_extension_ret, SQLITE_OK, false);
   }
 
+  sqlite3_trace_v2(connection_, SQLITE_TRACE_STMT, TraceCallback, this);
+
   return true;
 }
 
@@ -2286,30 +2289,6 @@ void DatabaseSync::LoadExtension(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
-void DatabaseSync::SetSqlTraceHook(const FunctionCallbackInfo<Value>& args) {
-  DatabaseSync* db;
-  ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
-  Environment* env = Environment::GetCurrent(args);
-  THROW_AND_RETURN_ON_BAD_STATE(env, !db->IsOpen(), "database is not open");
-  Isolate* isolate = env->isolate();
-
-  if (args[0]->IsNull() || args[0]->IsUndefined()) {
-    sqlite3_trace_v2(db->connection_, 0, nullptr, nullptr);
-    db->object()->SetInternalField(kTraceCallback, Null(isolate));
-    return;
-  }
-
-  if (!args[0]->IsFunction()) {
-    THROW_ERR_INVALID_ARG_TYPE(isolate,
-                               "The \"hook\" argument must be a function.");
-    return;
-  }
-
-  db->object()->SetInternalField(kTraceCallback, args[0].As<Function>());
-  sqlite3_trace_v2(
-      db->connection_, SQLITE_TRACE_STMT, DatabaseSync::TraceCallback, db);
-}
-
 void DatabaseSync::SetAuthorizer(const FunctionCallbackInfo<Value>& args) {
   DatabaseSync* db;
   ASSIGN_OR_RETURN_UNWRAP(&db, args.This());
@@ -2425,17 +2404,16 @@ int DatabaseSync::TraceCallback(unsigned int type,
 
   DatabaseSync* db = static_cast<DatabaseSync*>(user_data);
   Environment* env = db->env();
-  Isolate* isolate = env->isolate();
-  HandleScope handle_scope(isolate);
-  Local<Context> context = env->context();
 
-  Local<Value> cb =
-      db->object()->GetInternalField(kTraceCallback).template As<Value>();
-
-  if (!cb->IsFunction()) {
+  diagnostics_channel::Channel* ch =
+      diagnostics_channel::Channel::Get(env, "sqlite.db.query");
+  if (ch == nullptr || !ch->HasSubscribers()) {
     return 0;
   }
 
+  Isolate* isolate = env->isolate();
+  HandleScope handle_scope(isolate);
+
   char* expanded = sqlite3_expanded_sql(static_cast<sqlite3_stmt*>(p));
   Local<Value> sql_string;
   if (expanded != nullptr) {
@@ -2453,13 +2431,7 @@ int DatabaseSync::TraceCallback(unsigned int type,
     }
   }
 
-  Local<Function> callback = cb.As<Function>();
-  MaybeLocal<Value> retval =
-      callback->Call(context, Undefined(isolate), 1, &sql_string);
-
-  if (retval.IsEmpty()) {
-    db->SetIgnoreNextSQLiteError(true);
-  }
+  ch->Publish(env, sql_string);
 
   return 0;
 }
@@ -3839,8 +3811,6 @@ static void Initialize(Local<Object> target,
       isolate, db_tmpl, "enableDefensive", DatabaseSync::EnableDefensive);
   SetProtoMethod(
       isolate, db_tmpl, "loadExtension", DatabaseSync::LoadExtension);
-  SetProtoMethod(
-      isolate, db_tmpl, "setSqlTraceHook", DatabaseSync::SetSqlTraceHook);
   SetProtoMethod(
       isolate, db_tmpl, "setAuthorizer", DatabaseSync::SetAuthorizer);
   SetSideEffectFreeGetter(isolate,

src/node_sqlite.h

@@ -165,7 +165,6 @@ class DatabaseSync : public BaseObject {
   enum InternalFields {
     kAuthorizerCallback = BaseObject::kInternalFieldCount,
     kLimitsObject,
-    kTraceCallback,
     kInternalFieldCount
   };
 
@@ -203,7 +202,6 @@ class DatabaseSync : public BaseObject {
                                 const char* param2,
                                 const char* param3,
                                 const char* param4);
-  static void SetSqlTraceHook(const v8::FunctionCallbackInfo<v8::Value>& args);
   static int TraceCallback(unsigned int type,
                            void* user_data,
                            void* p,