Merge pull request #345 from jimklimov/JENKINS-75967

WithThreadName: add a way to disable with a JVM property [JENKINS-75967]

Author: jglick

README.md

@@ -7,3 +7,30 @@ This plugin provides APIs that are used by core Pipeline plugins for features su
 ## Version History
 
 See [the changelog](CHANGELOG.md).
+
+## Caveat emptor
+
+### Overheads of WithThreadName feature
+
+Some consumers of this plugin improve readability of JVM thread dumps by using
+the `org.jenkinsci.plugins.workflow.support.concurrent.WithThreadName` feature
+to temporarily clarify the purpose of that thread.
+
+This ends up calling `Thread.setName()` => `JVM_SetNativeThreadName()` => some
+native OS implementation (via `pthreads` or otherwise), both to enter and exit
+a context with this feature.
+
+In some use-cases, e.g. with a generated `parallel` pipeline with hundreds of
+stages then waiting in a Jenkins queue for considerable time, this can amount
+to tens of thousands of native (not very efficient on some systems) calls per
+second just for this troubleshooting aid, and can cause considerable slow-down
+of the Jenkins controller.
+
+If you suspect your controller's performance is impacted by this, please
+configure a JVM property or context setting
+`org.jenkinsci.plugins.workflow.support.concurrent.WithThreadName.enabled=false`
+to disable the feature's native calls.
+
+You can still trace attempts to rename the threads by adding a Jenkins log
+listener for the class name at `FINE` or louder level, and watching the
+log entry stream via Web UI or automatically-rotating files on the controller.

src/main/java/org/jenkinsci/plugins/workflow/support/concurrent/WithThreadName.java

@@ -24,20 +24,45 @@
 
 package org.jenkinsci.plugins.workflow.support.concurrent;
 
+import java.lang.*;
+import java.util.logging.Logger;
+
+import jenkins.util.SystemProperties;
+
 /**
  * Utility to temporarily append some information to the name of the current thread.
  * This is helpful for making thread dumps more readable and informative:
  * stack trace elements do not contain any information about object identity.
  */
 public final class WithThreadName implements AutoCloseable {
-
+    /** Save original thread name to recover it in {@link #close} call.
+     * Remains {@code null} if activity of this class is explicitly not
+     * {@link #enabled} on a particular deployment.
+     */
     private final String original;
 
+    /** Optional toggle via JVM properties to skip work here,
+     *  and forfeit easy debugging, e.g. on systems where
+     *  java.lang.Thread.setNativeName(Native Method) aka
+     *  JVM_SetNativeThreadName() and further platform
+     *  specific implementation takes inexplicably long.
+     */
+    private final static boolean enabled = SystemProperties.getBoolean(WithThreadName.class.getName() + ".enabled", true);
+
+    /** Help gauge how much and how often this code gets called */
+    private static final Logger LOGGER = Logger.getLogger(WithThreadName.class.getName());
+
     /**
      * Sets the current thread’s name.
      * @param suffix text to append to the original name
      */
     public WithThreadName(String suffix) {
+        if (!enabled) {
+            original = null;
+            LOGGER.fine(() -> "SKIP: Neutered WithThreadName(\"" + (suffix == null ? "(null)" : suffix) + "\")");
+            return;
+        }
+
         Thread t = Thread.currentThread();
         original = t.getName();
         t.setName(original + suffix);
@@ -47,6 +72,12 @@ public WithThreadName(String suffix) {
      * Restores the original name.
      */
     @Override public void close() {
+        if (!enabled) {
+            /* We did not track origin nor suffix here to be fast when skipping, so eh */
+            LOGGER.fine(() -> "SKIP: Neutered WithThreadName.close()");
+            return;
+        }
+
         Thread.currentThread().setName(original);
     }