5 files changed, 20 insertions, 16 deletions

diff --git a/src/analytics/analytics_thread.zig b/src/analytics/analytics_thread.zig
index 870dec5a5..2c778d589 100644
--- a/src/analytics/analytics_thread.zig
+++ b/src/analytics/analytics_thread.zig
@@ -346,9 +346,8 @@ const header_entry = Headers.Kv{
 
 fn readloop() anyerror!void {
     defer disabled = true;
-    Output.Source.configureThread();
+    Output.Source.configureNamedThread(thread, "Analytics");
     defer Output.flush();
-    thread.setName("Analytics") catch {};
 
     var event_list = try default_allocator.create(EventList);
     event_list.* = EventList.init();
diff --git a/src/cli/create_command.zig b/src/cli/create_command.zig
index 0a9cc2c5e..908b1c615 100644
--- a/src/cli/create_command.zig
+++ b/src/cli/create_command.zig
@@ -2169,8 +2169,7 @@ const GitHandler = struct {
         PATH: string,
         verbose: bool,
     ) void {
-        Output.Source.configureThread();
-        std.Thread.setName(thread, "git") catch {};
+        Output.Source.configureNamedThread(thread, "git");
         defer Output.flush();
         const outcome = if (verbose)
             run(destination, PATH, true) catch false
diff --git a/src/global.zig b/src/global.zig
index 08cc77fab..536b55be7 100644
--- a/src/global.zig
+++ b/src/global.zig
@@ -80,6 +80,19 @@ pub const Output = struct {
             source = Source.init(stdout_stream, stderr_stream);
         }
 
+        pub fn configureNamedThread(thread: std.Thread, name: stringZ) void {
+            if (source_set) return;
+            configureThread();
+
+            // On Linux, thread may be undefined 
+            // Fortunately, we can use a different syscall that only affects the current thread
+            if (Environment.isLinux) {
+                _ = std.os.linux.prctl(std.os.PR_SET_NAME, @ptrToInt(name.ptr), 0, 0, 0);
+            } else {
+                thread.setName(name) catch {};
+            }
+        }
+
         pub fn set(_source: *Source) void {
             source = _source.*;
             source_set = true;
diff --git a/src/http.zig b/src/http.zig
index 158092bd9..275dbb022 100644
--- a/src/http.zig
+++ b/src/http.zig
@@ -1111,7 +1111,7 @@ pub const RequestContext = struct {
         var js_thread: std.Thread = undefined;
         pub fn spawnThread(handler: *HandlerThread) !void {
             js_thread = try std.Thread.spawn(.{ .stack_size = 64 * 1024 * 1024 }, spawn, .{handler});
-            js_thread.setName("JavaScript SSR") catch {};
+            if (!Environment.isMac) js_thread.setName("JavaScript SSR") catch {};
             js_thread.detach();
         }
 
@@ -1125,11 +1125,7 @@ pub const RequestContext = struct {
             }
             var start_timer = std.time.Timer.start() catch unreachable;
 
-            var stdout = std.io.getStdOut();
-            var stderr = std.io.getStdErr();
-            var output_source = Output.Source.init(stdout, stderr);
-            defer Output.flush();
-            Output.Source.set(&output_source);
+            Output.Source.configureThread();
             @import("javascript/jsc/JavascriptCore.zig").JSCInitialize();
 
             js_ast.Stmt.Data.Store.create(std.heap.c_allocator);
diff --git a/src/watcher.zig b/src/watcher.zig
index f9ae5c3aa..f8de190bd 100644
--- a/src/watcher.zig
+++ b/src/watcher.zig
@@ -273,6 +273,7 @@ pub fn NewWatcher(comptime ContextType: type) type {
         allocator: *std.mem.Allocator,
         watchloop_handle: ?std.Thread.Id = null,
         cwd: string,
+        thread: std.Thread = undefined,
 
         pub const HashType = u32;
 
@@ -302,17 +303,13 @@ pub fn NewWatcher(comptime ContextType: type) type {
 
         pub fn start(this: *Watcher) !void {
             std.debug.assert(this.watchloop_handle == null);
-            var thread = try std.Thread.spawn(.{}, Watcher.watchLoop, .{this});
-            thread.setName("File Watcher") catch {};
+            this.thread = try std.Thread.spawn(.{}, Watcher.watchLoop, .{this});
         }
 
         // This must only be called from the watcher thread
         pub fn watchLoop(this: *Watcher) !void {
             this.watchloop_handle = std.Thread.getCurrentId();
-            var stdout = std.io.getStdOut();
-            var stderr = std.io.getStdErr();
-            var output_source = Output.Source.init(stdout, stderr);
-            Output.Source.set(&output_source);
+            Output.Source.configureNamedThread(this.thread, "File Watcher");
 
             defer Output.flush();
             if (FeatureFlags.verbose_watcher) Output.prettyln("Watcher started", .{});