Performance Tuning

# On Ubuntu/Debian: edit /etc/default/jenkins
# On RHEL/CentOS:   edit /etc/sysconfig/jenkins

# Open the Jenkins environment config
sudo nano /etc/default/jenkins

# Find the JAVA_ARGS line and replace with the tuned settings below
# Rule of thumb: set heap to 50-60% of total RAM, never more than 75%
# This server has 16 GB RAM → allocate 8 GB to Jenkins heap

JAVA_ARGS="\
  -Xms8g \
  -Xmx8g \
  -XX:+UseG1GC \
  -XX:MaxGCPauseMillis=200 \
  -XX:+ExplicitGCInvokesConcurrent \
  -Djava.awt.headless=true \
  -Xlog:gc:/var/log/jenkins/gc.log:time,uptime:filecount=5,filesize=20m"

# The options explained:
# -Xms8g -Xmx8g       → start and max heap both 8 GB (no resizing)
# -XX:+UseG1GC        → G1 garbage collector — better for large heaps
# -XX:MaxGCPauseMillis=200 → target max GC pause of 200ms
# -XX:+ExplicitGCInvokesConcurrent → don't stop the world for explicit GC calls
# -Djava.awt.headless=true → Jenkins needs no display — avoids AWT errors
# -Xlog:gc            → write GC events to a rolling log file

# Apply the changes by restarting Jenkins
sudo systemctl restart jenkins

# Verify the new JVM settings are active
# Look for -Xmx8g in the process arguments
ps aux | grep jenkins | grep -o "\-Xm[xs][^ ]*"

# Check the current heap usage via the Jenkins script console
# Paste this into http://JENKINS_URL/script
java -jar jenkins-cli.jar \
  -s http://jenkins-master-01:8080 \
  -auth admin:your-api-token \
  groovy = << 'EOF'
def rt = Runtime.getRuntime()
def mb = 1024 * 1024
println "JVM Heap Settings:"
println "  Max heap:   ${rt.maxMemory() / mb} MB"
println "  Total heap: ${rt.totalMemory() / mb} MB"
println "  Used heap:  ${(rt.totalMemory() - rt.freeMemory()) / mb} MB"
println "  Free heap:  ${rt.freeMemory() / mb} MB"
println "  Heap usage: ${ ((rt.totalMemory() - rt.freeMemory()) * 100 / rt.maxMemory()).round(1) }%"
EOF

// Run in the Jenkins Script Console to apply log rotation to ALL jobs at once
// This is useful when you inherit a Jenkins with hundreds of jobs and no retention policy
import jenkins.model.Jenkins
import hudson.tasks.LogRotator

def maxBuilds = 30    // keep the last 30 builds per job
def maxDays   = 30    // also discard builds older than 30 days
def maxArtifactBuilds = 5   // keep artifacts from only the last 5 builds
def maxArtifactDays   = 7   // discard artifacts older than 7 days

int updated = 0

Jenkins.instance.getAllItems(hudson.model.Job).each { job ->
    // Only update jobs that have NO existing log rotation configured
    // Don't overwrite jobs where someone has already set a specific policy
    if (job.buildDiscarder == null) {
        job.buildDiscarder = new LogRotator(
            maxDays,           // daysToKeep
            maxBuilds,         // numToKeepStr
            maxArtifactDays,   // artifactDaysToKeep
            maxArtifactBuilds  // artifactNumToKeep
        )
        job.save()
        updated++
        println "Updated: ${job.fullName}"
    }
}

println "\nDone — applied log rotation to ${updated} jobs."
println "Jobs already having a retention policy were skipped."

// Run in Script Console — clean up stale workspaces and orphaned data
import jenkins.model.Jenkins

// -------------------------------------------------------
// PART 1: Clean orphaned workspaces on all agents
// These are workspace directories for jobs that no longer exist
// -------------------------------------------------------
Jenkins.instance.nodes.each { node ->
    // Get the workspace root on this agent
    def wsRoot = node.rootPath
    if (wsRoot == null) {
        println "Skipping ${node.name} — agent offline"
        return
    }

    def cleaned = 0
    wsRoot.list().each { dir ->
        // Check if a job with this workspace name still exists
        def jobName = dir.name
        def job = Jenkins.instance.getItemByFullName(jobName)

        if (job == null) {
            // Job no longer exists — this workspace is orphaned
            println "Deleting orphaned workspace: ${node.name}/${dir.name}"
            dir.deleteRecursive()
            cleaned++
        }
    }
    println "${node.name}: cleaned ${cleaned} orphaned workspace(s)"
}

// -------------------------------------------------------
// PART 2: Clean the fingerprint database
// Fingerprints record which builds produced which artifacts
// Old fingerprints reference deleted builds — safe to clean
// -------------------------------------------------------
def fp = Jenkins.instance.fingerprintMap
if (fp != null) {
    def before = fp.size()
    Jenkins.instance.cleanupFingerprint()
    def after = fp.size()
    println "\nFingerprint cleanup: ${before - after} orphaned records removed"
    println "Remaining fingerprints: ${after}"
}

// Find plugins that have never been used in any pipeline — candidates for removal
// 'Never used' is a heuristic — verify manually before uninstalling
import jenkins.model.Jenkins

def pm = Jenkins.instance.pluginManager

// List all installed plugins sorted by name
// Cross-reference with your actual pipeline steps to identify unused ones
pm.plugins.sort { it.shortName }.each { plugin ->
    def deps  = plugin.getDependants().size()  // how many other plugins depend on this one
    def active = plugin.isActive() ? "" : " [DISABLED]"
    println "${plugin.shortName.padRight(45)} v${plugin.version.padRight(20)} dependants: ${deps}${active}"
}

println "\nTotal plugins: ${pm.plugins.size()}"
println "Tip: plugins with 0 dependants and that you don't actively use are candidates for removal."