How to check plugins usage in Jenkins

It's a good practice for a Jenkins administrator to check for installed plugins usage before updating one of them or to understand if some isn't used any more and can be uninstalled. The Enterprise Jenkins release provides a plugin (http://www.cloudbees.com/jenkins-enterprise-by-cloudbees-features-plugin-usage-plugin.cb) that shows in a tabular form the usage of the installed plugins across the different jobs in a Jenkins instance. It is a really simple but extremely helpful plugin. But how could you do the same if no Enterprise Jenkins is available for you? The same functionality can be implemented with a quite simple Groovy script using the Jenkins classes only. This script can be executed from the Jenkins script console (accessible from Manage Jenkins -> Script Console). Here's the code explained step by step. For a better understanding of this post I suggest you have the basics about the Jenkins model and the Jenkins Java classes.
First of all we need to get all the current instances of hudson.model.Project:

// Get all the current projects for this Jenkins instance
def currentProjects = Hudson.instance.items.findAll{ it instanceof Project }

Then we cycle among them. For each item we get its Descriptor. If it is the first occurence of a descriptor we add it as a new key to a Map. If not, simply associate the project to the plugin Descriptor key in the Map:

// Define the project grouped by descriptor Map
def projectsGroupedByDescriptor = [:]
 
// Cycle between projects
for(def project in currentProjects) {
    def items = new ArrayList(project.publishers.values())
    items.addAll(project.builders)
    // Cycle each item of the current project
    for(def item in items) {
         // Get the item Descriptor
        def descriptor = item.descriptor
        // If this is the first occurrence, put a new key into the Map
        if (!projectsGroupedByDescriptor.containsKey(descriptor)) {
            projectsGroupedByDescriptor.put(descriptor, [])
        }
        // Check, through the plugin descriptor, if the project uses the plugin
        if (!projectsGroupedByDescriptor[descriptor].contains(project)) {
            // Associate the project to the plugin descriptor key in the Map
            projectsGroupedByDescriptor[descriptor].add(project)
        }
    }   
}

This way we got all the content we need. Now we need to choose a way to render it. The following code is one simple proposal, but not the only one possible. For each plugin it prints its name, description and the Builder full class name (this is important because sometimes plugin developers forget to overwrite the getDisplayName() method of the plugin Descriptor, so you could see a bunch of Hello World plugin names in the final list and could be hard to recognize some of them) and then the list and the count of the jobs using it. The plugin list is ascending ordered by usage. The result is printed in the script console page:

// Define a StringBuffer for the final output
def output = ''<<''
// Format the output using the Map
for (def descriptor in projectsGroupedByDescriptor.keySet().sort { projectsGroupedByDescriptor.get(it).size() }) {
  output << descriptor.displayName
  output << '\n'
  output << (descriptor.plugin?.displayName?:'Jenkins Core')
  output << '\n'
  if(descriptor.class.name.lastIndexOf('$') != -1) {
      output << descriptor.class.name.substring(0, descriptor.class.name.lastIndexOf('$'))
  } else {
      output << descriptor.class.name
  }
  output << '\n'
  def projectCount = 0
  for (def project in projectsGroupedByDescriptor.get(descriptor)) {
    projectCount++
    output << '\t'
    output << project.fullDisplayName
    output << '\n'
  }
  output << 'Plugin usage: ' + projectCount
  output << '\n'
  output << '--------------------------------'
  output << '\n'
}

The output is something like this:

My Plugin 1
This is my first custom plugin for Jenkins
ie.googlielmo.MyFirstPlugin
    job 2
    job 3
Plugin usage: 2
--------------------------------
My Plugin 2
This is my second custom plugin for Jenkins
ie.googlielmo.MySecondPlugin
    job 1
    job 4
    job 5
Plugin usage: 3
--------------------------------
...

The code presented could be executed also in a System Groovy Script build step of a build job using the Groovy Plugin (https://wiki.jenkins-ci.org/display/JENKINS/Groovy+plugin).
This is a way to check the plugins usage safest than browsing across the XML desciptors of the single jobs (this is the most common solution I found in the web for this matter). Of course some improvement to the code above could be added and you can implement a better rendering exporting the results to a different format (XML, HTML, PDF, Json, etc.) but the goal of this post was to show how it is possible to implement an helpful functionality for Jenkins in a easy way simply using the available APIs. The solution proposed could be also used as a base suggestion to implement a custom plugin (if you really need it) to implement this check functionality.