From c977783875e6c59b5d089e9e6deec451a75e2d61 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Sat, 25 Feb 2023 18:32:40 +0530
Subject: [PATCH 01/20] worker: add support for worker name in inspector and
 trace_events

Fixes: https://github.com/nodejs/node/issues/41589
---
 lib/internal/worker.js            | 11 +++++++++--
 src/api/environment.cc            |  5 +++--
 src/inspector/worker_inspector.cc | 21 ++++++++++++---------
 src/inspector/worker_inspector.h  | 11 +++++++----
 src/inspector_agent.cc            |  6 +++---
 src/inspector_agent.h             |  2 +-
 src/node.h                        |  3 ++-
 src/node_worker.cc                | 11 ++++++++++-
 src/node_worker.h                 |  1 +
 test/cctest/test_environment.cc   |  2 +-
 10 files changed, 49 insertions(+), 24 deletions(-)

diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index ccb4e7d12a5541..021c1481a76d69 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -57,7 +57,7 @@ const {
 const { deserializeError } = require('internal/error_serdes');
 const { fileURLToPath, isURLInstance, pathToFileURL } = require('internal/url');
 const { kEmptyObject } = require('internal/util');
-const { validateArray } = require('internal/validators');
+const { validateArray, validateString } = require('internal/validators');
 
 const {
   ownsProcessState,
@@ -188,12 +188,19 @@ class Worker extends EventEmitter {
         options.env);
     }
 
+    let title_prefix = '';
+    if (options.titlePrefix) {
+      validateString(options.titlePrefix, 'options.titlePrefix');
+      title_prefix = options.titlePrefix;
+    }
+
     // Set up the C++ handle for the worker, as well as some internal wiring.
     this[kHandle] = new WorkerImpl(url,
                                    env === process.env ? null : env,
                                    options.execArgv,
                                    parseResourceLimits(options.resourceLimits),
-                                   !!(options.trackUnmanagedFds ?? true));
+                                   !!(options.trackUnmanagedFds ?? true),
+                                   title_prefix);
     if (this[kHandle].invalidExecArgv) {
       throw new ERR_WORKER_INVALID_EXEC_ARGV(this[kHandle].invalidExecArgv);
     }
diff --git a/src/api/environment.cc b/src/api/environment.cc
index 3d3f864d4e956c..9bcb458dfa37bc 100644
--- a/src/api/environment.cc
+++ b/src/api/environment.cc
@@ -508,12 +508,13 @@ void FreeEnvironment(Environment* env) {
 NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
     Environment* env,
     ThreadId thread_id,
-    const char* url) {
+    const char* url,
+    const char* title_prefix) {
   CHECK_NOT_NULL(env);
   CHECK_NE(thread_id.id, static_cast<uint64_t>(-1));
 #if HAVE_INSPECTOR
   return std::make_unique<InspectorParentHandleImpl>(
-      env->inspector_agent()->GetParentHandle(thread_id.id, url));
+      env->inspector_agent()->GetParentHandle(thread_id.id, url, title_prefix));
 #else
   return {};
 #endif
diff --git a/src/inspector/worker_inspector.cc b/src/inspector/worker_inspector.cc
index ff292ea4422b19..bbcd2612ec0770 100644
--- a/src/inspector/worker_inspector.cc
+++ b/src/inspector/worker_inspector.cc
@@ -14,9 +14,10 @@ class WorkerStartedRequest : public Request {
       uint64_t id,
       const std::string& url,
       std::shared_ptr<node::inspector::MainThreadHandle> worker_thread,
-      bool waiting)
+      bool waiting,
+      const std::string& title_prefix)
       : id_(id),
-        info_(BuildWorkerTitle(id), url, worker_thread),
+        info_(BuildWorkerTitle(id, title_prefix), url, worker_thread),
         waiting_(waiting) {}
   void Call(MainThreadInterface* thread) override {
     auto manager = thread->inspector_agent()->GetWorkerManager();
@@ -24,8 +25,8 @@ class WorkerStartedRequest : public Request {
   }
 
  private:
-  static std::string BuildWorkerTitle(int id) {
-    return "Worker " + std::to_string(id);
+  static std::string BuildWorkerTitle(int id, const std::string& title_prefix) {
+    return title_prefix + "Worker " + std::to_string(id);
   }
 
   uint64_t id_;
@@ -57,11 +58,13 @@ ParentInspectorHandle::ParentInspectorHandle(
     uint64_t id,
     const std::string& url,
     std::shared_ptr<MainThreadHandle> parent_thread,
-    bool wait_for_connect)
+    bool wait_for_connect,
+    const std::string& title_prefix)
     : id_(id),
       url_(url),
       parent_thread_(parent_thread),
-      wait_(wait_for_connect) {}
+      wait_(wait_for_connect),
+      title_prefix_(title_prefix) {}
 
 ParentInspectorHandle::~ParentInspectorHandle() {
   parent_thread_->Post(
@@ -71,7 +74,7 @@ ParentInspectorHandle::~ParentInspectorHandle() {
 void ParentInspectorHandle::WorkerStarted(
     std::shared_ptr<MainThreadHandle> worker_thread, bool waiting) {
   std::unique_ptr<Request> request(
-      new WorkerStartedRequest(id_, url_, worker_thread, waiting));
+      new WorkerStartedRequest(id_, url_, worker_thread, waiting, title_prefix_));
   parent_thread_->Post(std::move(request));
 }
 
@@ -97,9 +100,9 @@ void WorkerManager::WorkerStarted(uint64_t session_id,
 }
 
 std::unique_ptr<ParentInspectorHandle> WorkerManager::NewParentHandle(
-    uint64_t thread_id, const std::string& url) {
+    uint64_t thread_id, const std::string& url, const std::string& title_prefix) {
   bool wait = !delegates_waiting_on_start_.empty();
-  return std::make_unique<ParentInspectorHandle>(thread_id, url, thread_, wait);
+  return std::make_unique<ParentInspectorHandle>(thread_id, url, thread_, wait, title_prefix);
 }
 
 void WorkerManager::RemoveAttachDelegate(int id) {
diff --git a/src/inspector/worker_inspector.h b/src/inspector/worker_inspector.h
index 540d98c742fe05..f422807c0f8997 100644
--- a/src/inspector/worker_inspector.h
+++ b/src/inspector/worker_inspector.h
@@ -56,14 +56,16 @@ class ParentInspectorHandle {
   ParentInspectorHandle(uint64_t id,
                         const std::string& url,
                         std::shared_ptr<MainThreadHandle> parent_thread,
-                        bool wait_for_connect);
+                        bool wait_for_connect,
+                        const std::string& title_prefix);
   ~ParentInspectorHandle();
   std::unique_ptr<ParentInspectorHandle> NewParentInspectorHandle(
-      uint64_t thread_id, const std::string& url) {
+      uint64_t thread_id, const std::string& url, const std::string& title_prefix) {
     return std::make_unique<ParentInspectorHandle>(thread_id,
                                                    url,
                                                    parent_thread_,
-                                                   wait_);
+                                                   wait_,
+                                                   title_prefix);
   }
   void WorkerStarted(std::shared_ptr<MainThreadHandle> worker_thread,
                      bool waiting);
@@ -80,6 +82,7 @@ class ParentInspectorHandle {
   std::string url_;
   std::shared_ptr<MainThreadHandle> parent_thread_;
   bool wait_;
+  std::string title_prefix_;
 };
 
 class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
@@ -88,7 +91,7 @@ class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
                          : thread_(thread) {}
 
   std::unique_ptr<ParentInspectorHandle> NewParentHandle(
-      uint64_t thread_id, const std::string& url);
+      uint64_t thread_id, const std::string& url, const std::string& title_prefix);
   void WorkerStarted(uint64_t session_id, const WorkerInfo& info, bool waiting);
   void WorkerFinished(uint64_t session_id);
   std::unique_ptr<WorkerManagerEventHandle> SetAutoAttach(
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index ad193d477a5a5c..d984537573e6f4 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -952,7 +952,7 @@ void Agent::SetParentHandle(
 }
 
 std::unique_ptr<ParentInspectorHandle> Agent::GetParentHandle(
-    uint64_t thread_id, const std::string& url) {
+    uint64_t thread_id, const std::string& url, const std::string& title_prefix) {
   if (!parent_env_->should_create_inspector() && !client_) {
     ThrowUninitializedInspectorError(parent_env_);
     return std::unique_ptr<ParentInspectorHandle>{};
@@ -960,9 +960,9 @@ std::unique_ptr<ParentInspectorHandle> Agent::GetParentHandle(
 
   CHECK_NOT_NULL(client_);
   if (!parent_handle_) {
-    return client_->getWorkerManager()->NewParentHandle(thread_id, url);
+    return client_->getWorkerManager()->NewParentHandle(thread_id, url, title_prefix);
   } else {
-    return parent_handle_->NewParentInspectorHandle(thread_id, url);
+    return parent_handle_->NewParentInspectorHandle(thread_id, url, title_prefix);
   }
 }
 
diff --git a/src/inspector_agent.h b/src/inspector_agent.h
index 744e139df8f87a..019173e5b1b405 100644
--- a/src/inspector_agent.h
+++ b/src/inspector_agent.h
@@ -82,7 +82,7 @@ class Agent {
 
   void SetParentHandle(std::unique_ptr<ParentInspectorHandle> parent_handle);
   std::unique_ptr<ParentInspectorHandle> GetParentHandle(
-      uint64_t thread_id, const std::string& url);
+      uint64_t thread_id, const std::string& url, const std::string& title_prefix);
 
   // Called to create inspector sessions that can be used from the same thread.
   // The inspector responds by using the delegate to send messages back.
diff --git a/src/node.h b/src/node.h
index 635e5349f4ee88..4482e7dc5753d3 100644
--- a/src/node.h
+++ b/src/node.h
@@ -677,7 +677,8 @@ NODE_EXTERN Environment* CreateEnvironment(
 NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
     Environment* parent_env,
     ThreadId child_thread_id,
-    const char* child_url);
+    const char* child_url,
+    const char* title_prefix);
 
 struct StartExecutionCallbackInfo {
   v8::Local<v8::Object> process_object;
diff --git a/src/node_worker.cc b/src/node_worker.cc
index 66ab3dfd8ceb33..14644d431f2875 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -49,6 +49,7 @@ constexpr double kMB = 1024 * 1024;
 Worker::Worker(Environment* env,
                Local<Object> wrap,
                const std::string& url,
+               const std::string& title_prefix,
                std::shared_ptr<PerIsolateOptions> per_isolate_opts,
                std::vector<std::string>&& exec_argv,
                std::shared_ptr<KVStore> env_vars,
@@ -83,7 +84,7 @@ Worker::Worker(Environment* env,
       .Check();
 
   inspector_parent_handle_ = GetInspectorParentHandle(
-      env, thread_id_, url.c_str());
+      env, thread_id_, url.c_str(), title_prefix.c_str());
 
   argv_ = std::vector<std::string>{env->argv()[0]};
   // Mark this Worker object as weak until we actually start the thread.
@@ -467,6 +468,7 @@ void Worker::New(const FunctionCallbackInfo<Value>& args) {
   }
 
   std::string url;
+  std::string title_prefix;
   std::shared_ptr<PerIsolateOptions> per_isolate_opts = nullptr;
   std::shared_ptr<KVStore> env_vars = nullptr;
 
@@ -479,6 +481,12 @@ void Worker::New(const FunctionCallbackInfo<Value>& args) {
     url.append(value.out(), value.length());
   }
 
+  if (!args[5]->IsNullOrUndefined()) {
+    Utf8Value value(
+        isolate, args[5]->ToString(env->context()).FromMaybe(Local<String>()));
+    title_prefix.append(value.out(), value.length());
+  }
+
   if (args[1]->IsNull()) {
     // Means worker.env = { ...process.env }.
     env_vars = env->env_vars()->Clone(isolate);
@@ -589,6 +597,7 @@ void Worker::New(const FunctionCallbackInfo<Value>& args) {
   Worker* worker = new Worker(env,
                               args.This(),
                               url,
+                              title_prefix,
                               per_isolate_opts,
                               std::move(exec_argv_out),
                               env_vars,
diff --git a/src/node_worker.h b/src/node_worker.h
index dcb58d13e0e6f9..266d5ed09d01df 100644
--- a/src/node_worker.h
+++ b/src/node_worker.h
@@ -30,6 +30,7 @@ class Worker : public AsyncWrap {
   Worker(Environment* env,
          v8::Local<v8::Object> wrap,
          const std::string& url,
+         const std::string& title_prefix,
          std::shared_ptr<PerIsolateOptions> per_isolate_opts,
          std::vector<std::string>&& exec_argv,
          std::shared_ptr<KVStore> env_vars,
diff --git a/test/cctest/test_environment.cc b/test/cctest/test_environment.cc
index 547c8ddbffe243..787564f4036c6c 100644
--- a/test/cctest/test_environment.cc
+++ b/test/cctest/test_environment.cc
@@ -449,7 +449,7 @@ TEST_F(EnvironmentTest, InspectorMultipleEmbeddedEnvironments) {
   ChildEnvironmentData data;
   data.thread_id = node::AllocateEnvironmentThreadId();
   data.inspector_parent_handle =
-      GetInspectorParentHandle(*env, data.thread_id, "file:///embedded.js");
+      GetInspectorParentHandle(*env, data.thread_id, "file:///embedded.js", "");
   CHECK(data.inspector_parent_handle);
   data.platform = GetMultiIsolatePlatform(*env);
   CHECK_NOT_NULL(data.platform);

From 35811f5f59ffbef2b22e932be60b4b9efa92b62c Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Sun, 26 Feb 2023 11:53:24 +0530
Subject: [PATCH 02/20] fixup! remove breaking change

---
 src/api/environment.cc          | 14 ++++++++++++++
 src/node.h                      |  5 +++++
 test/cctest/test_environment.cc |  2 +-
 3 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/api/environment.cc b/src/api/environment.cc
index 9bcb458dfa37bc..c562b6c2e01734 100644
--- a/src/api/environment.cc
+++ b/src/api/environment.cc
@@ -505,6 +505,20 @@ void FreeEnvironment(Environment* env) {
   delete env;
 }
 
+NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
+    Environment* env,
+    ThreadId thread_id,
+    const char* url) {
+  CHECK_NOT_NULL(env);
+  CHECK_NE(thread_id.id, static_cast<uint64_t>(-1));
+#if HAVE_INSPECTOR
+  return std::make_unique<InspectorParentHandleImpl>(
+      env->inspector_agent()->GetParentHandle(thread_id.id, url, ""));
+#else
+  return {};
+#endif
+}
+
 NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
     Environment* env,
     ThreadId thread_id,
diff --git a/src/node.h b/src/node.h
index 4482e7dc5753d3..526b7f7b50703a 100644
--- a/src/node.h
+++ b/src/node.h
@@ -674,6 +674,11 @@ NODE_EXTERN Environment* CreateEnvironment(
 // Environment, together with the inspector handle.
 // This method should not be called while the parent Environment is active
 // on another thread.
+NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
+    Environment* parent_env,
+    ThreadId child_thread_id,
+    const char* child_url);
+
 NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
     Environment* parent_env,
     ThreadId child_thread_id,
diff --git a/test/cctest/test_environment.cc b/test/cctest/test_environment.cc
index 787564f4036c6c..547c8ddbffe243 100644
--- a/test/cctest/test_environment.cc
+++ b/test/cctest/test_environment.cc
@@ -449,7 +449,7 @@ TEST_F(EnvironmentTest, InspectorMultipleEmbeddedEnvironments) {
   ChildEnvironmentData data;
   data.thread_id = node::AllocateEnvironmentThreadId();
   data.inspector_parent_handle =
-      GetInspectorParentHandle(*env, data.thread_id, "file:///embedded.js", "");
+      GetInspectorParentHandle(*env, data.thread_id, "file:///embedded.js");
   CHECK(data.inspector_parent_handle);
   data.platform = GetMultiIsolatePlatform(*env);
   CHECK_NOT_NULL(data.platform);

From 2680a3e09e4808cf6af0cbae9ecedbd982b2029f Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Sun, 26 Feb 2023 13:19:13 +0530
Subject: [PATCH 03/20] fixup! add a test

---
 test/parallel/test-worker-title-prefix.js | 25 +++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 test/parallel/test-worker-title-prefix.js

diff --git a/test/parallel/test-worker-title-prefix.js b/test/parallel/test-worker-title-prefix.js
new file mode 100644
index 00000000000000..5ba3b5945a2520
--- /dev/null
+++ b/test/parallel/test-worker-title-prefix.js
@@ -0,0 +1,25 @@
+'use strict';
+
+const common = require('../common');
+common.skipIfInspectorDisabled();
+const assert = require('assert');
+const { Worker, isMainThread } = require('worker_threads');
+
+const { Session } = require('inspector');
+
+if (isMainThread) {
+  const titlePrefix = 'Hello Thread ';
+  new Worker(__filename, {
+    workerData: 'Test Worker',
+    titlePrefix,
+  });
+
+  const session = new Session();
+  session.connect();
+  session.on('NodeWorker.attachedToWorker', ({ params: { workerInfo } }) => {
+    const id = workerInfo.id;
+    const expectedTitle = `${titlePrefix}Worker ${id}`;
+    assert.strictEqual(workerInfo.title, expectedTitle);
+  });
+  session.post('NodeWorker.enable', { waitForDebuggerOnStart: false });
+}

From b6738e1d359e1511e16361bda4b3ad7dc37f8cf3 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Sun, 26 Feb 2023 13:30:27 +0530
Subject: [PATCH 04/20] fixup! add doc

---
 doc/api/worker_threads.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index 43f10ae489a9a0..116566e74ee48c 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -906,6 +906,10 @@ if (isMainThread) {
 <!-- YAML
 added: v10.5.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/46832
+    description: Added support for a `titlePrefix` option, which allows
+                 adding a custom prefix to the worker title.
   - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34584
     description: The `filename` parameter can be a WHATWG `URL` object using
@@ -1004,6 +1008,9 @@ changes:
       used for generated code.
     * `stackSizeMb` {number} The default maximum stack size for the thread.
       Small values may lead to unusable Worker instances. **Default:** `4`.
+  * `titlePrefix` {string} A prefix to use for the title of the worker thread.
+    The final title will be `titlePrefix` + `Worker ${threadId}`. **Default:**
+    `''`.
 
 ### Event: `'error'`
 

From 152195098a094311f9e0a39ebe0e2a01bcf98b31 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Sun, 26 Feb 2023 15:42:20 +0530
Subject: [PATCH 05/20] fixup! lint

---
 src/inspector/worker_inspector.cc | 11 +++++++----
 src/inspector/worker_inspector.h  |  8 ++++++--
 src/inspector_agent.cc            | 10 +++++++---
 src/inspector_agent.h             |  4 +++-
 4 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/src/inspector/worker_inspector.cc b/src/inspector/worker_inspector.cc
index bbcd2612ec0770..a6e837d78f779d 100644
--- a/src/inspector/worker_inspector.cc
+++ b/src/inspector/worker_inspector.cc
@@ -73,8 +73,8 @@ ParentInspectorHandle::~ParentInspectorHandle() {
 
 void ParentInspectorHandle::WorkerStarted(
     std::shared_ptr<MainThreadHandle> worker_thread, bool waiting) {
-  std::unique_ptr<Request> request(
-      new WorkerStartedRequest(id_, url_, worker_thread, waiting, title_prefix_));
+  std::unique_ptr<Request> request(new WorkerStartedRequest(
+      id_, url_, worker_thread, waiting, title_prefix_));
   parent_thread_->Post(std::move(request));
 }
 
@@ -100,9 +100,12 @@ void WorkerManager::WorkerStarted(uint64_t session_id,
 }
 
 std::unique_ptr<ParentInspectorHandle> WorkerManager::NewParentHandle(
-    uint64_t thread_id, const std::string& url, const std::string& title_prefix) {
+    uint64_t thread_id,
+    const std::string& url,
+    const std::string& title_prefix) {
   bool wait = !delegates_waiting_on_start_.empty();
-  return std::make_unique<ParentInspectorHandle>(thread_id, url, thread_, wait, title_prefix);
+  return std::make_unique<ParentInspectorHandle>(
+      thread_id, url, thread_, wait, title_prefix);
 }
 
 void WorkerManager::RemoveAttachDelegate(int id) {
diff --git a/src/inspector/worker_inspector.h b/src/inspector/worker_inspector.h
index f422807c0f8997..d3ba2c8ec3865b 100644
--- a/src/inspector/worker_inspector.h
+++ b/src/inspector/worker_inspector.h
@@ -60,7 +60,9 @@ class ParentInspectorHandle {
                         const std::string& title_prefix);
   ~ParentInspectorHandle();
   std::unique_ptr<ParentInspectorHandle> NewParentInspectorHandle(
-      uint64_t thread_id, const std::string& url, const std::string& title_prefix) {
+      uint64_t thread_id,
+      const std::string& url,
+      const std::string& title_prefix) {
     return std::make_unique<ParentInspectorHandle>(thread_id,
                                                    url,
                                                    parent_thread_,
@@ -91,7 +93,9 @@ class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
                          : thread_(thread) {}
 
   std::unique_ptr<ParentInspectorHandle> NewParentHandle(
-      uint64_t thread_id, const std::string& url, const std::string& title_prefix);
+      uint64_t thread_id,
+      const std::string& url,
+      const std::string& title_prefix);
   void WorkerStarted(uint64_t session_id, const WorkerInfo& info, bool waiting);
   void WorkerFinished(uint64_t session_id);
   std::unique_ptr<WorkerManagerEventHandle> SetAutoAttach(
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index d984537573e6f4..2784c62c1a19d7 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -952,7 +952,9 @@ void Agent::SetParentHandle(
 }
 
 std::unique_ptr<ParentInspectorHandle> Agent::GetParentHandle(
-    uint64_t thread_id, const std::string& url, const std::string& title_prefix) {
+    uint64_t thread_id,
+    const std::string& url,
+    const std::string& title_prefix) {
   if (!parent_env_->should_create_inspector() && !client_) {
     ThrowUninitializedInspectorError(parent_env_);
     return std::unique_ptr<ParentInspectorHandle>{};
@@ -960,9 +962,11 @@ std::unique_ptr<ParentInspectorHandle> Agent::GetParentHandle(
 
   CHECK_NOT_NULL(client_);
   if (!parent_handle_) {
-    return client_->getWorkerManager()->NewParentHandle(thread_id, url, title_prefix);
+    return client_->getWorkerManager()->NewParentHandle(
+        thread_id, url, title_prefix);
   } else {
-    return parent_handle_->NewParentInspectorHandle(thread_id, url, title_prefix);
+    return parent_handle_->NewParentInspectorHandle(
+        thread_id, url, title_prefix);
   }
 }
 
diff --git a/src/inspector_agent.h b/src/inspector_agent.h
index 019173e5b1b405..fcd023123703cc 100644
--- a/src/inspector_agent.h
+++ b/src/inspector_agent.h
@@ -82,7 +82,9 @@ class Agent {
 
   void SetParentHandle(std::unique_ptr<ParentInspectorHandle> parent_handle);
   std::unique_ptr<ParentInspectorHandle> GetParentHandle(
-      uint64_t thread_id, const std::string& url, const std::string& title_prefix);
+      uint64_t thread_id,
+      const std::string& url,
+      const std::string& title_prefix);
 
   // Called to create inspector sessions that can be used from the same thread.
   // The inspector responds by using the delegate to send messages back.

From 2b4f7426757ebaf5edbfcccd794a3047c85a6e25 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Sun, 26 Feb 2023 15:52:31 +0530
Subject: [PATCH 06/20] fixup! lint

---
 src/inspector/worker_inspector.h | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/inspector/worker_inspector.h b/src/inspector/worker_inspector.h
index d3ba2c8ec3865b..f617aee99548e3 100644
--- a/src/inspector/worker_inspector.h
+++ b/src/inspector/worker_inspector.h
@@ -63,11 +63,8 @@ class ParentInspectorHandle {
       uint64_t thread_id,
       const std::string& url,
       const std::string& title_prefix) {
-    return std::make_unique<ParentInspectorHandle>(thread_id,
-                                                   url,
-                                                   parent_thread_,
-                                                   wait_,
-                                                   title_prefix);
+    return std::make_unique<ParentInspectorHandle>(
+        thread_id, url, parent_thread_, wait_, title_prefix);
   }
   void WorkerStarted(std::shared_ptr<MainThreadHandle> worker_thread,
                      bool waiting);

From 38be52f40d19497c81f048c13c70fbe61ed96c52 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Sun, 26 Feb 2023 20:19:56 +0530
Subject: [PATCH 07/20] fixup! null check

Co-authored-by: Anna Henningsen <github@addaleax.net>
---
 src/api/environment.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/api/environment.cc b/src/api/environment.cc
index c562b6c2e01734..4fddf7220ccb30 100644
--- a/src/api/environment.cc
+++ b/src/api/environment.cc
@@ -525,6 +525,7 @@ NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
     const char* url,
     const char* title_prefix) {
   CHECK_NOT_NULL(env);
+  if (title_prefix == nullptr) title_prefix = "";
   CHECK_NE(thread_id.id, static_cast<uint64_t>(-1));
 #if HAVE_INSPECTOR
   return std::make_unique<InspectorParentHandleImpl>(

From 53e709829ff11f8089013c8c2f1c369ba78ba525 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Sun, 26 Feb 2023 20:21:29 +0530
Subject: [PATCH 08/20] fixup! simplify function

---
 src/api/environment.cc | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/src/api/environment.cc b/src/api/environment.cc
index 4fddf7220ccb30..83547fa5700adc 100644
--- a/src/api/environment.cc
+++ b/src/api/environment.cc
@@ -509,14 +509,7 @@ NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
     Environment* env,
     ThreadId thread_id,
     const char* url) {
-  CHECK_NOT_NULL(env);
-  CHECK_NE(thread_id.id, static_cast<uint64_t>(-1));
-#if HAVE_INSPECTOR
-  return std::make_unique<InspectorParentHandleImpl>(
-      env->inspector_agent()->GetParentHandle(thread_id.id, url, ""));
-#else
-  return {};
-#endif
+  return GetInspectorParentHandle(env, thread_id, url, "");
 }
 
 NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(

From 54286bdf07d53b354f76bc08ac7cc02e01a88c5a Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Mon, 27 Feb 2023 18:47:14 +0530
Subject: [PATCH 09/20] fixup! update name formation

---
 lib/internal/worker.js            | 3 ++-
 src/inspector/worker_inspector.cc | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 021c1481a76d69..8265d47eab9875 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -16,6 +16,7 @@ const {
   SafeArrayIterator,
   SafeMap,
   String,
+  StringPrototypeTrim,
   Symbol,
   SymbolFor,
   TypedArrayPrototypeFill,
@@ -191,7 +192,7 @@ class Worker extends EventEmitter {
     let title_prefix = '';
     if (options.titlePrefix) {
       validateString(options.titlePrefix, 'options.titlePrefix');
-      title_prefix = options.titlePrefix;
+      title_prefix = StringPrototypeTrim(options.titlePrefix);
     }
 
     // Set up the C++ handle for the worker, as well as some internal wiring.
diff --git a/src/inspector/worker_inspector.cc b/src/inspector/worker_inspector.cc
index a6e837d78f779d..7ca6dc8c56cdb3 100644
--- a/src/inspector/worker_inspector.cc
+++ b/src/inspector/worker_inspector.cc
@@ -26,7 +26,8 @@ class WorkerStartedRequest : public Request {
 
  private:
   static std::string BuildWorkerTitle(int id, const std::string& title_prefix) {
-    return title_prefix + "Worker " + std::to_string(id);
+    return "[Worker " + std::to_string(id) + "]" +
+           (title_prefix == "" ? "" : " " + title_prefix);
   }
 
   uint64_t id_;

From 2e9c50befa31db863be0f8865b3b6d2e9ff3a73a Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Tue, 28 Feb 2023 13:01:00 +0530
Subject: [PATCH 10/20] fixup! refactor option name

---
 doc/api/worker_threads.md                     | 10 +++++-----
 lib/internal/worker.js                        | 10 +++++-----
 src/api/environment.cc                        |  6 +++---
 src/inspector/worker_inspector.cc             | 20 +++++++++----------
 src/inspector/worker_inspector.h              | 10 +++++-----
 src/inspector_agent.cc                        |  6 +++---
 src/inspector_agent.h                         |  2 +-
 src/node.h                                    |  2 +-
 src/node_worker.cc                            | 10 +++++-----
 src/node_worker.h                             |  2 +-
 ...er-title-prefix.js => test-worker-name.js} |  6 +++---
 11 files changed, 42 insertions(+), 42 deletions(-)
 rename test/parallel/{test-worker-title-prefix.js => test-worker-name.js} (84%)

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index 116566e74ee48c..c3ce1e58a04d86 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -908,8 +908,8 @@ added: v10.5.0
 changes:
   - version: REPLACEME
     pr-url: https://github.com/nodejs/node/pull/46832
-    description: Added support for a `titlePrefix` option, which allows
-                 adding a custom prefix to the worker title.
+    description: Added support for a `name` option, which allows
+                 adding a name to worker title for debugging.
   - version: v14.9.0
     pr-url: https://github.com/nodejs/node/pull/34584
     description: The `filename` parameter can be a WHATWG `URL` object using
@@ -1008,9 +1008,9 @@ changes:
       used for generated code.
     * `stackSizeMb` {number} The default maximum stack size for the thread.
       Small values may lead to unusable Worker instances. **Default:** `4`.
-  * `titlePrefix` {string} A prefix to use for the title of the worker thread.
-    The final title will be `titlePrefix` + `Worker ${threadId}`. **Default:**
-    `''`.
+  * `name` {string} An optional `name` to be appended to the worker title
+    for debuggin/identification purposes, making the final title as 
+    `[Worker ${id}] ${name}`. **Default:** `''`.
 
 ### Event: `'error'`
 
diff --git a/lib/internal/worker.js b/lib/internal/worker.js
index 8265d47eab9875..83054eafedc967 100644
--- a/lib/internal/worker.js
+++ b/lib/internal/worker.js
@@ -189,10 +189,10 @@ class Worker extends EventEmitter {
         options.env);
     }
 
-    let title_prefix = '';
-    if (options.titlePrefix) {
-      validateString(options.titlePrefix, 'options.titlePrefix');
-      title_prefix = StringPrototypeTrim(options.titlePrefix);
+    let name = '';
+    if (options.name) {
+      validateString(options.name, 'options.name');
+      name = StringPrototypeTrim(options.name);
     }
 
     // Set up the C++ handle for the worker, as well as some internal wiring.
@@ -201,7 +201,7 @@ class Worker extends EventEmitter {
                                    options.execArgv,
                                    parseResourceLimits(options.resourceLimits),
                                    !!(options.trackUnmanagedFds ?? true),
-                                   title_prefix);
+                                   name);
     if (this[kHandle].invalidExecArgv) {
       throw new ERR_WORKER_INVALID_EXEC_ARGV(this[kHandle].invalidExecArgv);
     }
diff --git a/src/api/environment.cc b/src/api/environment.cc
index 83547fa5700adc..250e7802c69b12 100644
--- a/src/api/environment.cc
+++ b/src/api/environment.cc
@@ -516,13 +516,13 @@ NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
     Environment* env,
     ThreadId thread_id,
     const char* url,
-    const char* title_prefix) {
+    const char* name) {
   CHECK_NOT_NULL(env);
-  if (title_prefix == nullptr) title_prefix = "";
+  if (name == nullptr) name = "";
   CHECK_NE(thread_id.id, static_cast<uint64_t>(-1));
 #if HAVE_INSPECTOR
   return std::make_unique<InspectorParentHandleImpl>(
-      env->inspector_agent()->GetParentHandle(thread_id.id, url, title_prefix));
+      env->inspector_agent()->GetParentHandle(thread_id.id, url, name));
 #else
   return {};
 #endif
diff --git a/src/inspector/worker_inspector.cc b/src/inspector/worker_inspector.cc
index 7ca6dc8c56cdb3..e670925f868146 100644
--- a/src/inspector/worker_inspector.cc
+++ b/src/inspector/worker_inspector.cc
@@ -15,9 +15,9 @@ class WorkerStartedRequest : public Request {
       const std::string& url,
       std::shared_ptr<node::inspector::MainThreadHandle> worker_thread,
       bool waiting,
-      const std::string& title_prefix)
+      const std::string& name)
       : id_(id),
-        info_(BuildWorkerTitle(id, title_prefix), url, worker_thread),
+        info_(BuildWorkerTitle(id, name), url, worker_thread),
         waiting_(waiting) {}
   void Call(MainThreadInterface* thread) override {
     auto manager = thread->inspector_agent()->GetWorkerManager();
@@ -25,9 +25,9 @@ class WorkerStartedRequest : public Request {
   }
 
  private:
-  static std::string BuildWorkerTitle(int id, const std::string& title_prefix) {
-    return "[Worker " + std::to_string(id) + "]" +
-           (title_prefix == "" ? "" : " " + title_prefix);
+  static std::string BuildWorkerTitle(int id, const std::string& name) {
+    return "[worker " + std::to_string(id) + "]" +
+           (name == "" ? "" : " " + name);
   }
 
   uint64_t id_;
@@ -60,12 +60,12 @@ ParentInspectorHandle::ParentInspectorHandle(
     const std::string& url,
     std::shared_ptr<MainThreadHandle> parent_thread,
     bool wait_for_connect,
-    const std::string& title_prefix)
+    const std::string& name)
     : id_(id),
       url_(url),
       parent_thread_(parent_thread),
       wait_(wait_for_connect),
-      title_prefix_(title_prefix) {}
+      name_(name) {}
 
 ParentInspectorHandle::~ParentInspectorHandle() {
   parent_thread_->Post(
@@ -75,7 +75,7 @@ ParentInspectorHandle::~ParentInspectorHandle() {
 void ParentInspectorHandle::WorkerStarted(
     std::shared_ptr<MainThreadHandle> worker_thread, bool waiting) {
   std::unique_ptr<Request> request(new WorkerStartedRequest(
-      id_, url_, worker_thread, waiting, title_prefix_));
+      id_, url_, worker_thread, waiting, name_));
   parent_thread_->Post(std::move(request));
 }
 
@@ -103,10 +103,10 @@ void WorkerManager::WorkerStarted(uint64_t session_id,
 std::unique_ptr<ParentInspectorHandle> WorkerManager::NewParentHandle(
     uint64_t thread_id,
     const std::string& url,
-    const std::string& title_prefix) {
+    const std::string& name) {
   bool wait = !delegates_waiting_on_start_.empty();
   return std::make_unique<ParentInspectorHandle>(
-      thread_id, url, thread_, wait, title_prefix);
+      thread_id, url, thread_, wait, name);
 }
 
 void WorkerManager::RemoveAttachDelegate(int id) {
diff --git a/src/inspector/worker_inspector.h b/src/inspector/worker_inspector.h
index f617aee99548e3..f7e76b331d58bd 100644
--- a/src/inspector/worker_inspector.h
+++ b/src/inspector/worker_inspector.h
@@ -57,14 +57,14 @@ class ParentInspectorHandle {
                         const std::string& url,
                         std::shared_ptr<MainThreadHandle> parent_thread,
                         bool wait_for_connect,
-                        const std::string& title_prefix);
+                        const std::string& name);
   ~ParentInspectorHandle();
   std::unique_ptr<ParentInspectorHandle> NewParentInspectorHandle(
       uint64_t thread_id,
       const std::string& url,
-      const std::string& title_prefix) {
+      const std::string& name) {
     return std::make_unique<ParentInspectorHandle>(
-        thread_id, url, parent_thread_, wait_, title_prefix);
+        thread_id, url, parent_thread_, wait_, name);
   }
   void WorkerStarted(std::shared_ptr<MainThreadHandle> worker_thread,
                      bool waiting);
@@ -81,7 +81,7 @@ class ParentInspectorHandle {
   std::string url_;
   std::shared_ptr<MainThreadHandle> parent_thread_;
   bool wait_;
-  std::string title_prefix_;
+  std::string name_;
 };
 
 class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
@@ -92,7 +92,7 @@ class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
   std::unique_ptr<ParentInspectorHandle> NewParentHandle(
       uint64_t thread_id,
       const std::string& url,
-      const std::string& title_prefix);
+      const std::string& name);
   void WorkerStarted(uint64_t session_id, const WorkerInfo& info, bool waiting);
   void WorkerFinished(uint64_t session_id);
   std::unique_ptr<WorkerManagerEventHandle> SetAutoAttach(
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index 2784c62c1a19d7..47458b6b8342b0 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -954,7 +954,7 @@ void Agent::SetParentHandle(
 std::unique_ptr<ParentInspectorHandle> Agent::GetParentHandle(
     uint64_t thread_id,
     const std::string& url,
-    const std::string& title_prefix) {
+    const std::string& name) {
   if (!parent_env_->should_create_inspector() && !client_) {
     ThrowUninitializedInspectorError(parent_env_);
     return std::unique_ptr<ParentInspectorHandle>{};
@@ -963,10 +963,10 @@ std::unique_ptr<ParentInspectorHandle> Agent::GetParentHandle(
   CHECK_NOT_NULL(client_);
   if (!parent_handle_) {
     return client_->getWorkerManager()->NewParentHandle(
-        thread_id, url, title_prefix);
+        thread_id, url, name);
   } else {
     return parent_handle_->NewParentInspectorHandle(
-        thread_id, url, title_prefix);
+        thread_id, url, name);
   }
 }
 
diff --git a/src/inspector_agent.h b/src/inspector_agent.h
index fcd023123703cc..563c3e4d10f154 100644
--- a/src/inspector_agent.h
+++ b/src/inspector_agent.h
@@ -84,7 +84,7 @@ class Agent {
   std::unique_ptr<ParentInspectorHandle> GetParentHandle(
       uint64_t thread_id,
       const std::string& url,
-      const std::string& title_prefix);
+      const std::string& name);
 
   // Called to create inspector sessions that can be used from the same thread.
   // The inspector responds by using the delegate to send messages back.
diff --git a/src/node.h b/src/node.h
index 526b7f7b50703a..c65a907b088553 100644
--- a/src/node.h
+++ b/src/node.h
@@ -683,7 +683,7 @@ NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
     Environment* parent_env,
     ThreadId child_thread_id,
     const char* child_url,
-    const char* title_prefix);
+    const char* name);
 
 struct StartExecutionCallbackInfo {
   v8::Local<v8::Object> process_object;
diff --git a/src/node_worker.cc b/src/node_worker.cc
index 14644d431f2875..ac28dbe6511af4 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -49,7 +49,7 @@ constexpr double kMB = 1024 * 1024;
 Worker::Worker(Environment* env,
                Local<Object> wrap,
                const std::string& url,
-               const std::string& title_prefix,
+               const std::string& name,
                std::shared_ptr<PerIsolateOptions> per_isolate_opts,
                std::vector<std::string>&& exec_argv,
                std::shared_ptr<KVStore> env_vars,
@@ -84,7 +84,7 @@ Worker::Worker(Environment* env,
       .Check();
 
   inspector_parent_handle_ = GetInspectorParentHandle(
-      env, thread_id_, url.c_str(), title_prefix.c_str());
+      env, thread_id_, url.c_str(), name.c_str());
 
   argv_ = std::vector<std::string>{env->argv()[0]};
   // Mark this Worker object as weak until we actually start the thread.
@@ -468,7 +468,7 @@ void Worker::New(const FunctionCallbackInfo<Value>& args) {
   }
 
   std::string url;
-  std::string title_prefix;
+  std::string name;
   std::shared_ptr<PerIsolateOptions> per_isolate_opts = nullptr;
   std::shared_ptr<KVStore> env_vars = nullptr;
 
@@ -484,7 +484,7 @@ void Worker::New(const FunctionCallbackInfo<Value>& args) {
   if (!args[5]->IsNullOrUndefined()) {
     Utf8Value value(
         isolate, args[5]->ToString(env->context()).FromMaybe(Local<String>()));
-    title_prefix.append(value.out(), value.length());
+    name.append(value.out(), value.length());
   }
 
   if (args[1]->IsNull()) {
@@ -597,7 +597,7 @@ void Worker::New(const FunctionCallbackInfo<Value>& args) {
   Worker* worker = new Worker(env,
                               args.This(),
                               url,
-                              title_prefix,
+                              name,
                               per_isolate_opts,
                               std::move(exec_argv_out),
                               env_vars,
diff --git a/src/node_worker.h b/src/node_worker.h
index 266d5ed09d01df..dcecc0334287b0 100644
--- a/src/node_worker.h
+++ b/src/node_worker.h
@@ -30,7 +30,7 @@ class Worker : public AsyncWrap {
   Worker(Environment* env,
          v8::Local<v8::Object> wrap,
          const std::string& url,
-         const std::string& title_prefix,
+         const std::string& name,
          std::shared_ptr<PerIsolateOptions> per_isolate_opts,
          std::vector<std::string>&& exec_argv,
          std::shared_ptr<KVStore> env_vars,
diff --git a/test/parallel/test-worker-title-prefix.js b/test/parallel/test-worker-name.js
similarity index 84%
rename from test/parallel/test-worker-title-prefix.js
rename to test/parallel/test-worker-name.js
index 5ba3b5945a2520..222637ec9f7c43 100644
--- a/test/parallel/test-worker-title-prefix.js
+++ b/test/parallel/test-worker-name.js
@@ -8,17 +8,17 @@ const { Worker, isMainThread } = require('worker_threads');
 const { Session } = require('inspector');
 
 if (isMainThread) {
-  const titlePrefix = 'Hello Thread ';
+  const name = 'Hello Thread ';
   new Worker(__filename, {
     workerData: 'Test Worker',
-    titlePrefix,
+    name,
   });
 
   const session = new Session();
   session.connect();
   session.on('NodeWorker.attachedToWorker', ({ params: { workerInfo } }) => {
     const id = workerInfo.id;
-    const expectedTitle = `${titlePrefix}Worker ${id}`;
+    const expectedTitle = `[Worker ${id}] ${name}`;
     assert.strictEqual(workerInfo.title, expectedTitle);
   });
   session.post('NodeWorker.enable', { waitForDebuggerOnStart: false });

From 7d7c4e8f06fd2182a847e469d4c3e8f1c97054da Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Tue, 28 Feb 2023 13:29:33 +0530
Subject: [PATCH 11/20] fixup! update worker trace name

---
 src/node_worker.cc                            |  6 ++--
 src/node_worker.h                             |  2 ++
 ...-trace-events-worker-metadata-with-name.js | 31 +++++++++++++++++++
 .../test-trace-events-worker-metadata.js      |  2 +-
 4 files changed, 37 insertions(+), 4 deletions(-)
 create mode 100644 test/parallel/test-trace-events-worker-metadata-with-name.js

diff --git a/src/node_worker.cc b/src/node_worker.cc
index ac28dbe6511af4..2ad8090f185297 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -59,6 +59,7 @@ Worker::Worker(Environment* env,
       exec_argv_(exec_argv),
       platform_(env->isolate_data()->platform()),
       thread_id_(AllocateEnvironmentThreadId()),
+      name_(name),
       env_vars_(env_vars),
       snapshot_data_(snapshot_data) {
   Debug(this, "Creating new worker instance with thread id %llu",
@@ -265,11 +266,10 @@ size_t Worker::NearHeapLimit(void* data, size_t current_heap_limit,
 }
 
 void Worker::Run() {
-  std::string name = "WorkerThread ";
-  name += std::to_string(thread_id_.id);
+  std::string trace_name ="[worker " + std::to_string(thread_id_.id) + "]" + (name_ == "" ? "" : " " + name_);
   TRACE_EVENT_METADATA1(
       "__metadata", "thread_name", "name",
-      TRACE_STR_COPY(name.c_str()));
+      TRACE_STR_COPY(trace_name.c_str()));
   CHECK_NOT_NULL(platform_);
 
   Debug(this, "Creating isolate for worker with id %llu", thread_id_.id);
diff --git a/src/node_worker.h b/src/node_worker.h
index dcecc0334287b0..531e2b5287010f 100644
--- a/src/node_worker.h
+++ b/src/node_worker.h
@@ -100,6 +100,8 @@ class Worker : public AsyncWrap {
   ExitCode exit_code_ = ExitCode::kNoFailure;
   ThreadId thread_id_;
   uintptr_t stack_base_ = 0;
+  // Optional name used for debugging in inspector and trace events.
+  std::string name_;
 
   // Custom resource constraints:
   double resource_limits_[kTotalResourceLimitCount];
diff --git a/test/parallel/test-trace-events-worker-metadata-with-name.js b/test/parallel/test-trace-events-worker-metadata-with-name.js
new file mode 100644
index 00000000000000..6c3a44f9566d9c
--- /dev/null
+++ b/test/parallel/test-trace-events-worker-metadata-with-name.js
@@ -0,0 +1,31 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+const fs = require('fs');
+const { isMainThread } = require('worker_threads');
+
+if (isMainThread) {
+  const CODE = 'const { Worker } = require(\'worker_threads\'); ' +
+               `new Worker('${__filename.replace(/\\/g, '/')}', { name: 'foo' })`;
+  const FILE_NAME = 'node_trace.1.log';
+  const tmpdir = require('../common/tmpdir');
+  tmpdir.refresh();
+  process.chdir(tmpdir.path);
+
+  const proc = cp.spawn(process.execPath,
+                        [ '--trace-event-categories', 'node',
+                          '-e', CODE ]);
+  proc.once('exit', common.mustCall(() => {
+    assert(fs.existsSync(FILE_NAME));
+    fs.readFile(FILE_NAME, common.mustCall((err, data) => {
+      const traces = JSON.parse(data.toString()).traceEvents;
+      assert(traces.length > 0);
+      assert(traces.some((trace) =>
+        trace.cat === '__metadata' && trace.name === 'thread_name' &&
+          trace.args.name === '[worker 1] foo'));
+    }));
+  }));
+} else {
+  // Do nothing here.
+}
diff --git a/test/parallel/test-trace-events-worker-metadata.js b/test/parallel/test-trace-events-worker-metadata.js
index 4600ba3f7ec2fd..8b4d0be9c60713 100644
--- a/test/parallel/test-trace-events-worker-metadata.js
+++ b/test/parallel/test-trace-events-worker-metadata.js
@@ -23,7 +23,7 @@ if (isMainThread) {
       assert(traces.length > 0);
       assert(traces.some((trace) =>
         trace.cat === '__metadata' && trace.name === 'thread_name' &&
-          trace.args.name === 'WorkerThread 1'));
+          trace.args.name === '[worker 1]'));
     }));
   }));
 } else {

From 402bc6c9e356b319bb36cbf4503a8968d97aada5 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Tue, 28 Feb 2023 13:32:48 +0530
Subject: [PATCH 12/20] fixup! lint

---
 src/node_worker.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/node_worker.cc b/src/node_worker.cc
index 2ad8090f185297..17675c200d7846 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -266,7 +266,8 @@ size_t Worker::NearHeapLimit(void* data, size_t current_heap_limit,
 }
 
 void Worker::Run() {
-  std::string trace_name ="[worker " + std::to_string(thread_id_.id) + "]" + (name_ == "" ? "" : " " + name_);
+  std::string trace_name = "[worker " + std::to_string(thread_id_.id) + "]" +
+                           (name_ == "" ? "" : " " + name_);
   TRACE_EVENT_METADATA1(
       "__metadata", "thread_name", "name",
       TRACE_STR_COPY(trace_name.c_str()));

From 1bd70c2e6843d3082cc8dd2a61aaa60b17e4f3a5 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Tue, 28 Feb 2023 13:38:31 +0530
Subject: [PATCH 13/20] fixup! lint

---
 doc/api/worker_threads.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index c3ce1e58a04d86..90a8ec8640e707 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -1009,7 +1009,7 @@ changes:
     * `stackSizeMb` {number} The default maximum stack size for the thread.
       Small values may lead to unusable Worker instances. **Default:** `4`.
   * `name` {string} An optional `name` to be appended to the worker title
-    for debuggin/identification purposes, making the final title as 
+    for debuggin/identification purposes, making the final title as
     `[Worker ${id}] ${name}`. **Default:** `''`.
 
 ### Event: `'error'`

From 28f812e4dd1cbd14b8362ea3e9e03a75701fa058 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Tue, 28 Feb 2023 13:47:53 +0530
Subject: [PATCH 14/20] fixup! lint again

---
 src/api/environment.cc            |  5 +----
 src/inspector/worker_inspector.cc |  8 +++-----
 src/inspector/worker_inspector.h  |  8 ++------
 src/inspector_agent.cc            | 10 +++-------
 src/inspector_agent.h             |  4 +---
 src/node_worker.cc                |  7 +++----
 6 files changed, 13 insertions(+), 29 deletions(-)

diff --git a/src/api/environment.cc b/src/api/environment.cc
index 250e7802c69b12..e188852ca30ccf 100644
--- a/src/api/environment.cc
+++ b/src/api/environment.cc
@@ -513,10 +513,7 @@ NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
 }
 
 NODE_EXTERN std::unique_ptr<InspectorParentHandle> GetInspectorParentHandle(
-    Environment* env,
-    ThreadId thread_id,
-    const char* url,
-    const char* name) {
+    Environment* env, ThreadId thread_id, const char* url, const char* name) {
   CHECK_NOT_NULL(env);
   if (name == nullptr) name = "";
   CHECK_NE(thread_id.id, static_cast<uint64_t>(-1));
diff --git a/src/inspector/worker_inspector.cc b/src/inspector/worker_inspector.cc
index e670925f868146..fd479181e9566c 100644
--- a/src/inspector/worker_inspector.cc
+++ b/src/inspector/worker_inspector.cc
@@ -74,8 +74,8 @@ ParentInspectorHandle::~ParentInspectorHandle() {
 
 void ParentInspectorHandle::WorkerStarted(
     std::shared_ptr<MainThreadHandle> worker_thread, bool waiting) {
-  std::unique_ptr<Request> request(new WorkerStartedRequest(
-      id_, url_, worker_thread, waiting, name_));
+  std::unique_ptr<Request> request(
+      new WorkerStartedRequest(id_, url_, worker_thread, waiting, name_));
   parent_thread_->Post(std::move(request));
 }
 
@@ -101,9 +101,7 @@ void WorkerManager::WorkerStarted(uint64_t session_id,
 }
 
 std::unique_ptr<ParentInspectorHandle> WorkerManager::NewParentHandle(
-    uint64_t thread_id,
-    const std::string& url,
-    const std::string& name) {
+    uint64_t thread_id, const std::string& url, const std::string& name) {
   bool wait = !delegates_waiting_on_start_.empty();
   return std::make_unique<ParentInspectorHandle>(
       thread_id, url, thread_, wait, name);
diff --git a/src/inspector/worker_inspector.h b/src/inspector/worker_inspector.h
index f7e76b331d58bd..d3254d5aa0ebe4 100644
--- a/src/inspector/worker_inspector.h
+++ b/src/inspector/worker_inspector.h
@@ -60,9 +60,7 @@ class ParentInspectorHandle {
                         const std::string& name);
   ~ParentInspectorHandle();
   std::unique_ptr<ParentInspectorHandle> NewParentInspectorHandle(
-      uint64_t thread_id,
-      const std::string& url,
-      const std::string& name) {
+      uint64_t thread_id, const std::string& url, const std::string& name) {
     return std::make_unique<ParentInspectorHandle>(
         thread_id, url, parent_thread_, wait_, name);
   }
@@ -90,9 +88,7 @@ class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
                          : thread_(thread) {}
 
   std::unique_ptr<ParentInspectorHandle> NewParentHandle(
-      uint64_t thread_id,
-      const std::string& url,
-      const std::string& name);
+      uint64_t thread_id, const std::string& url, const std::string& name);
   void WorkerStarted(uint64_t session_id, const WorkerInfo& info, bool waiting);
   void WorkerFinished(uint64_t session_id);
   std::unique_ptr<WorkerManagerEventHandle> SetAutoAttach(
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index 47458b6b8342b0..02842c7e5e792c 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -952,9 +952,7 @@ void Agent::SetParentHandle(
 }
 
 std::unique_ptr<ParentInspectorHandle> Agent::GetParentHandle(
-    uint64_t thread_id,
-    const std::string& url,
-    const std::string& name) {
+    uint64_t thread_id, const std::string& url, const std::string& name) {
   if (!parent_env_->should_create_inspector() && !client_) {
     ThrowUninitializedInspectorError(parent_env_);
     return std::unique_ptr<ParentInspectorHandle>{};
@@ -962,11 +960,9 @@ std::unique_ptr<ParentInspectorHandle> Agent::GetParentHandle(
 
   CHECK_NOT_NULL(client_);
   if (!parent_handle_) {
-    return client_->getWorkerManager()->NewParentHandle(
-        thread_id, url, name);
+    return client_->getWorkerManager()->NewParentHandle(thread_id, url, name);
   } else {
-    return parent_handle_->NewParentInspectorHandle(
-        thread_id, url, name);
+    return parent_handle_->NewParentInspectorHandle(thread_id, url, name);
   }
 }
 
diff --git a/src/inspector_agent.h b/src/inspector_agent.h
index 563c3e4d10f154..01c5f70be6f860 100644
--- a/src/inspector_agent.h
+++ b/src/inspector_agent.h
@@ -82,9 +82,7 @@ class Agent {
 
   void SetParentHandle(std::unique_ptr<ParentInspectorHandle> parent_handle);
   std::unique_ptr<ParentInspectorHandle> GetParentHandle(
-      uint64_t thread_id,
-      const std::string& url,
-      const std::string& name);
+      uint64_t thread_id, const std::string& url, const std::string& name);
 
   // Called to create inspector sessions that can be used from the same thread.
   // The inspector responds by using the delegate to send messages back.
diff --git a/src/node_worker.cc b/src/node_worker.cc
index 17675c200d7846..606e8cb74ba70f 100644
--- a/src/node_worker.cc
+++ b/src/node_worker.cc
@@ -84,8 +84,8 @@ Worker::Worker(Environment* env,
                 Number::New(env->isolate(), static_cast<double>(thread_id_.id)))
       .Check();
 
-  inspector_parent_handle_ = GetInspectorParentHandle(
-      env, thread_id_, url.c_str(), name.c_str());
+  inspector_parent_handle_ =
+      GetInspectorParentHandle(env, thread_id_, url.c_str(), name.c_str());
 
   argv_ = std::vector<std::string>{env->argv()[0]};
   // Mark this Worker object as weak until we actually start the thread.
@@ -269,8 +269,7 @@ void Worker::Run() {
   std::string trace_name = "[worker " + std::to_string(thread_id_.id) + "]" +
                            (name_ == "" ? "" : " " + name_);
   TRACE_EVENT_METADATA1(
-      "__metadata", "thread_name", "name",
-      TRACE_STR_COPY(trace_name.c_str()));
+      "__metadata", "thread_name", "name", TRACE_STR_COPY(trace_name.c_str()));
   CHECK_NOT_NULL(platform_);
 
   Debug(this, "Creating isolate for worker with id %llu", thread_id_.id);

From 1dd3e70fc0e602deb66ef87054d3815e9fd2a79b Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Wed, 1 Mar 2023 11:02:28 +0530
Subject: [PATCH 15/20] fixup! surround with mustcall

---
 test/parallel/test-worker-name.js | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/test/parallel/test-worker-name.js b/test/parallel/test-worker-name.js
index 222637ec9f7c43..af722b0ffd6783 100644
--- a/test/parallel/test-worker-name.js
+++ b/test/parallel/test-worker-name.js
@@ -8,7 +8,7 @@ const { Worker, isMainThread } = require('worker_threads');
 const { Session } = require('inspector');
 
 if (isMainThread) {
-  const name = 'Hello Thread ';
+  const name = 'Hello Thread';
   new Worker(__filename, {
     workerData: 'Test Worker',
     name,
@@ -16,10 +16,12 @@ if (isMainThread) {
 
   const session = new Session();
   session.connect();
-  session.on('NodeWorker.attachedToWorker', ({ params: { workerInfo } }) => {
-    const id = workerInfo.id;
+  session.on('NodeWorker.attachedToWorker', common.mustCall(({ params: { workerInfo } }) => {
+    const id = workerInfo.workerId;
     const expectedTitle = `[Worker ${id}] ${name}`;
     assert.strictEqual(workerInfo.title, expectedTitle);
-  });
+  }));
   session.post('NodeWorker.enable', { waitForDebuggerOnStart: false });
+} else {
+  console.log('inside worker');
 }

From 239c849f680c2fd6b5a6e6f7ae2a8d93eec3cd67 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Wed, 1 Mar 2023 11:02:59 +0530
Subject: [PATCH 16/20] fixup!

---
 test/parallel/test-worker-name.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/parallel/test-worker-name.js b/test/parallel/test-worker-name.js
index af722b0ffd6783..29a85ce702beff 100644
--- a/test/parallel/test-worker-name.js
+++ b/test/parallel/test-worker-name.js
@@ -23,5 +23,5 @@ if (isMainThread) {
   }));
   session.post('NodeWorker.enable', { waitForDebuggerOnStart: false });
 } else {
-  console.log('inside worker');
+  // nothing to do
 }

From 21f8114be20cdf6e2cc0e960f49c067070798b43 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Wed, 1 Mar 2023 12:42:33 +0530
Subject: [PATCH 17/20] fixup! move the session to worker thread

---
 test/parallel/test-worker-name.js | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/test/parallel/test-worker-name.js b/test/parallel/test-worker-name.js
index 29a85ce702beff..5248b590794962 100644
--- a/test/parallel/test-worker-name.js
+++ b/test/parallel/test-worker-name.js
@@ -3,25 +3,24 @@
 const common = require('../common');
 common.skipIfInspectorDisabled();
 const assert = require('assert');
-const { Worker, isMainThread } = require('worker_threads');
+const { Worker, isMainThread, parentPort } = require('worker_threads');
 
 const { Session } = require('inspector');
 
 if (isMainThread) {
   const name = 'Hello Thread';
-  new Worker(__filename, {
-    workerData: 'Test Worker',
+  const worker = new Worker(__filename, {
     name,
   });
-
+  const expectedTitle = `[worker 1] ${name}`;
+  worker.once('message', common.mustCall((message) => {
+    assert.strictEqual(message, expectedTitle);
+  }));
+} else {
   const session = new Session();
-  session.connect();
+  session.connectToMainThread();
   session.on('NodeWorker.attachedToWorker', common.mustCall(({ params: { workerInfo } }) => {
-    const id = workerInfo.workerId;
-    const expectedTitle = `[Worker ${id}] ${name}`;
-    assert.strictEqual(workerInfo.title, expectedTitle);
+    parentPort.postMessage(workerInfo.title);
   }));
   session.post('NodeWorker.enable', { waitForDebuggerOnStart: false });
-} else {
-  // nothing to do
 }

From e75082dd03f5539df77a8250fe56c4cf203cf0f2 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Thu, 2 Mar 2023 12:58:14 +0530
Subject: [PATCH 18/20] fixup! keep worker alive

---
 test/parallel/test-worker-name.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/parallel/test-worker-name.js b/test/parallel/test-worker-name.js
index 5248b590794962..4e18dc0ce108ef 100644
--- a/test/parallel/test-worker-name.js
+++ b/test/parallel/test-worker-name.js
@@ -15,9 +15,11 @@ if (isMainThread) {
   const expectedTitle = `[worker 1] ${name}`;
   worker.once('message', common.mustCall((message) => {
     assert.strictEqual(message, expectedTitle);
+    worker.postMessage('done');
   }));
 } else {
   const session = new Session();
+  parentPort.once('message', () => {});
   session.connectToMainThread();
   session.on('NodeWorker.attachedToWorker', common.mustCall(({ params: { workerInfo } }) => {
     parentPort.postMessage(workerInfo.title);

From 48d97d65e9aefa41074bfb984714093d9dc753a1 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Thu, 2 Mar 2023 23:55:26 +0530
Subject: [PATCH 19/20] fixup! move worker code to a fixture

---
 test/fixtures/worker-name.js      | 17 +++++++++++++++++
 test/parallel/test-worker-name.js | 20 +++++++-------------
 2 files changed, 24 insertions(+), 13 deletions(-)
 create mode 100644 test/fixtures/worker-name.js

diff --git a/test/fixtures/worker-name.js b/test/fixtures/worker-name.js
new file mode 100644
index 00000000000000..45adea78f7e725
--- /dev/null
+++ b/test/fixtures/worker-name.js
@@ -0,0 +1,17 @@
+const { Session } = require('inspector');
+const { parentPort } = require('worker_threads');
+
+const session = new Session();
+
+parentPort.once('message', () => {}); // Prevent the worker from exiting.
+
+session.connectToMainThread();
+
+session.on(
+  'NodeWorker.attachedToWorker',
+  ({ params: { workerInfo } }) => {
+    // send the worker title to the main thread
+    parentPort.postMessage(workerInfo.title);
+  }
+);
+session.post('NodeWorker.enable', { waitForDebuggerOnStart: false });
diff --git a/test/parallel/test-worker-name.js b/test/parallel/test-worker-name.js
index 4e18dc0ce108ef..952fcee0e05429 100644
--- a/test/parallel/test-worker-name.js
+++ b/test/parallel/test-worker-name.js
@@ -1,28 +1,22 @@
 'use strict';
 
 const common = require('../common');
+const fixtures = require('../common/fixtures');
+
 common.skipIfInspectorDisabled();
-const assert = require('assert');
-const { Worker, isMainThread, parentPort } = require('worker_threads');
+common.skipIfWorker(); // This test requires both main and worker threads.
 
-const { Session } = require('inspector');
+const assert = require('assert');
+const { Worker, isMainThread } = require('worker_threads');
 
 if (isMainThread) {
   const name = 'Hello Thread';
-  const worker = new Worker(__filename, {
+  const expectedTitle = `[worker 1] ${name}`;
+  const worker = new Worker(fixtures.path('worker-name.js'), {
     name,
   });
-  const expectedTitle = `[worker 1] ${name}`;
   worker.once('message', common.mustCall((message) => {
     assert.strictEqual(message, expectedTitle);
     worker.postMessage('done');
   }));
-} else {
-  const session = new Session();
-  parentPort.once('message', () => {});
-  session.connectToMainThread();
-  session.on('NodeWorker.attachedToWorker', common.mustCall(({ params: { workerInfo } }) => {
-    parentPort.postMessage(workerInfo.title);
-  }));
-  session.post('NodeWorker.enable', { waitForDebuggerOnStart: false });
 }

From f5090a8036b930223dc6ffb16fc7742cbf1b7569 Mon Sep 17 00:00:00 2001
From: Debadree Chatterjee <debadree333@gmail.com>
Date: Fri, 3 Mar 2023 00:09:08 +0530
Subject: [PATCH 20/20] fixup! typo

---
 doc/api/worker_threads.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/worker_threads.md b/doc/api/worker_threads.md
index 90a8ec8640e707..674424f6f0bf90 100644
--- a/doc/api/worker_threads.md
+++ b/doc/api/worker_threads.md
@@ -1010,7 +1010,7 @@ changes:
       Small values may lead to unusable Worker instances. **Default:** `4`.
   * `name` {string} An optional `name` to be appended to the worker title
     for debuggin/identification purposes, making the final title as
-    `[Worker ${id}] ${name}`. **Default:** `''`.
+    `[worker ${id}] ${name}`. **Default:** `''`.
 
 ### Event: `'error'`