Adding metrics for code coverage (#545)

* Base implementation

* Need to update to latest LTS because of new dependency

* Implementing CodeCoverageCollector

* Fixing calculation of coverage metrics

* Adding Tests

* Removing unnecessary constructor call

pom.xml

@@ -18,13 +18,14 @@
 
   <properties>
     <!-- when updated the io.jenkins.tools.bom:bom-X.Y.Z must be updated too -->
-    <jenkins.version>2.361.4</jenkins.version>
+    <jenkins.version>2.387.3</jenkins.version>
     <java.level>11</java.level>
 
     <prometheus.simpleclient.version>0.16.0</prometheus.simpleclient.version>
     <slf4j.version>2.0.7</slf4j.version>
 
     <cloudbees-disk-usage-simple.version>0.10</cloudbees-disk-usage-simple.version>
+    <code-coverage-api.version>4.7.0</code-coverage-api.version>
     <metrics.version>4.1.6.1</metrics.version>
     <pipeline-rest-api.version>2.21</pipeline-rest-api.version>
 
@@ -47,6 +48,9 @@
   </licenses>
 
   <developers>
+    <developer>
+      <id>Waschndolos</id>
+    </developer>
     <developer>
       <id>devguy</id>
       <name>Marky Jackson</name>
@@ -79,8 +83,8 @@
     <dependencies>
       <dependency>
         <groupId>io.jenkins.tools.bom</groupId>
-        <artifactId>bom-2.319.x</artifactId>
-        <version>1654.vcb_69d035fa_20</version>
+        <artifactId>bom-2.387.x</artifactId>
+        <version>2329.v078520e55c19</version>
         <scope>import</scope>
         <type>pom</type>
       </dependency>
@@ -120,6 +124,12 @@
       <version>${cloudbees-disk-usage-simple.version}</version>
       <optional>true</optional>
     </dependency>
+    <dependency>
+      <groupId>io.jenkins.plugins</groupId>
+      <artifactId>code-coverage-api</artifactId>
+      <version>${code-coverage-api.version}</version>
+      <optional>true</optional>
+    </dependency>
     <dependency>
       <groupId>org.jenkins-ci.plugins</groupId>
       <artifactId>junit</artifactId>

src/main/java/org/jenkinsci/plugins/prometheus/BaseCollector.java

@@ -0,0 +1,19 @@
+package org.jenkinsci.plugins.prometheus;
+
+import io.prometheus.client.Collector;
+import io.prometheus.client.Gauge;
+import org.jenkinsci.plugins.prometheus.util.ConfigurationUtils;
+
+public abstract class BaseCollector extends Collector {
+
+
+    protected static Gauge.Builder newGaugeBuilder(String... labels) {
+        return newGaugeBuilder().labelNames(labels);
+    }
+
+    protected static Gauge.Builder newGaugeBuilder() {
+        return Gauge.build()
+                .namespace(ConfigurationUtils.getNamespace())
+                .subsystem(ConfigurationUtils.getSubSystem());
+    }
+}

src/main/java/org/jenkinsci/plugins/prometheus/CodeCoverageCollector.java

@@ -0,0 +1,94 @@
+package org.jenkinsci.plugins.prometheus;
+
+import hudson.model.Job;
+import hudson.model.Run;
+import io.jenkins.plugins.coverage.metrics.steps.CoverageBuildAction;
+import io.prometheus.client.Collector;
+import jenkins.model.Jenkins;
+import org.apache.commons.collections.CollectionUtils;
+import org.jenkinsci.plugins.prometheus.collectors.CollectorFactory;
+import org.jenkinsci.plugins.prometheus.collectors.CollectorType;
+import org.jenkinsci.plugins.prometheus.collectors.MetricCollector;
+import org.jenkinsci.plugins.prometheus.config.PrometheusConfiguration;
+import org.jenkinsci.plugins.prometheus.util.Jobs;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CodeCoverageCollector extends BaseCollector {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(CodeCoverageCollector.class);
+
+    @Override
+    public List<MetricFamilySamples> collect() {
+
+        if (!isCodeCoverageAPIPluginLoaded()) {
+            LOGGER.warn("Cannot collect code coverage data because plugin Code Coverage API (shortname: 'code-coverage-api') is not loaded.");
+            return Collections.emptyList();
+        }
+
+        if (!isCodeCoverageCollectionConfigured()) {
+            return Collections.emptyList();
+        }
+
+        List<List<MetricFamilySamples>> samples = new ArrayList<>();
+        Jobs.forEachJob(job -> CollectionUtils.addIgnoreNull(samples, collectCoverageMetricForJob(job)));
+
+
+        return samples.stream().flatMap(Collection::stream).collect(Collectors.toList());
+    }
+
+    private List<MetricFamilySamples> collectCoverageMetricForJob(Job<?,?> job) {
+        if (job == null) {
+            return Collections.emptyList();
+        }
+
+        Run<?,?> lastBuild = job.getLastBuild();
+        if (lastBuild == null || lastBuild.isBuilding()) {
+            return Collections.emptyList();
+        }
+
+        CoverageBuildAction coverageBuildAction = lastBuild.getAction(CoverageBuildAction.class);
+        if (coverageBuildAction == null) {
+            return Collections.emptyList();
+        }
+
+        CollectorFactory factory = new CollectorFactory();
+        List<MetricCollector<Run<?,?>, ? extends Collector>> collectors = new ArrayList<>();
+
+        collectors.add(factory.createCoverageRunCollector(CollectorType.COVERAGE_CLASS_COVERED, new String[]{"job_name"}));
+        collectors.add(factory.createCoverageRunCollector(CollectorType.COVERAGE_CLASS_MISSED, new String[]{"job_name"}));
+        collectors.add(factory.createCoverageRunCollector(CollectorType.COVERAGE_CLASS_TOTAL, new String[]{"job_name"}));
+
+        collectors.add(factory.createCoverageRunCollector(CollectorType.COVERAGE_BRANCH_COVERED, new String[]{"job_name"}));
+        collectors.add(factory.createCoverageRunCollector(CollectorType.COVERAGE_BRANCH_MISSED, new String[]{"job_name"}));
+        collectors.add(factory.createCoverageRunCollector(CollectorType.COVERAGE_BRANCH_TOTAL, new String[]{"job_name"}));
+
+        collectors.add(factory.createCoverageRunCollector(CollectorType.COVERAGE_INSTRUCTION_COVERED, new String[]{"job_name"}));
+        collectors.add(factory.createCoverageRunCollector(CollectorType.COVERAGE_INSTRUCTION_MISSED, new String[]{"job_name"}));
+        collectors.add(factory.createCoverageRunCollector(CollectorType.COVERAGE_INSTRUCTION_TOTAL, new String[]{"job_name"}));
+
+        collectors.add(factory.createCoverageRunCollector(CollectorType.COVERAGE_FILE_COVERED, new String[]{"job_name"}));
+        collectors.add(factory.createCoverageRunCollector(CollectorType.COVERAGE_FILE_MISSED, new String[]{"job_name"}));
+        collectors.add(factory.createCoverageRunCollector(CollectorType.COVERAGE_FILE_TOTAL, new String[]{"job_name"}));
+
+        collectors.forEach(c -> c.calculateMetric(lastBuild, new String[]{job.getName()}));
+
+        return collectors.stream()
+                .map(MetricCollector::collect)
+                .flatMap(Collection::stream)
+                .collect(Collectors.toList());
+    }
+    private boolean isCodeCoverageAPIPluginLoaded() {
+        return Jenkins.get().getPlugin("code-coverage-api") != null;
+    }
+
+    private boolean isCodeCoverageCollectionConfigured() {
+        return PrometheusConfiguration.get().isCollectCodeCoverage();
+    }
+}

src/main/java/org/jenkinsci/plugins/prometheus/collectors/CollectorFactory.java

@@ -8,10 +8,12 @@
 import io.prometheus.client.Collector;
 import jenkins.model.Jenkins;
 import org.jenkinsci.plugins.prometheus.collectors.builds.BuildCollectorFactory;
+import org.jenkinsci.plugins.prometheus.collectors.coverage.CoverageCollectorFactory;
 import org.jenkinsci.plugins.prometheus.collectors.disk.DiskCollectorFactory;
 import org.jenkinsci.plugins.prometheus.collectors.executors.ExecutorCollectorFactory;
 import org.jenkinsci.plugins.prometheus.collectors.jenkins.JenkinsCollectorFactory;
 import org.jenkinsci.plugins.prometheus.collectors.jobs.JobCollectorFactory;
+import org.json.Cookie;
 
 import java.nio.file.FileStore;
 
@@ -23,12 +25,19 @@ public class CollectorFactory {
     private final ExecutorCollectorFactory executorCollectorFactory;
     private final DiskCollectorFactory diskCollectorFactory;
 
+    private final CoverageCollectorFactory coverageCollectorFactory;
+
     public CollectorFactory() {
         buildCollectorFactory = new BuildCollectorFactory();
         jobCollectorFactory = new JobCollectorFactory();
         jenkinsCollectorFactory = new JenkinsCollectorFactory();
         executorCollectorFactory = new ExecutorCollectorFactory();
         diskCollectorFactory = new DiskCollectorFactory();
+        coverageCollectorFactory = new CoverageCollectorFactory();
+    }
+
+    public MetricCollector<Run<?,?>, ? extends Collector> createCoverageRunCollector(CollectorType type, String[] labelNames) {
+        return coverageCollectorFactory.createCollector(type, labelNames);
     }
 
     public MetricCollector<Run<?, ?>, ? extends Collector> createRunCollector(CollectorType type, String[] labelNames, String prefix) {

src/main/java/org/jenkinsci/plugins/prometheus/collectors/CollectorType.java

@@ -34,7 +34,27 @@ public enum CollectorType {
     FILE_STORE_CAPACITY_GAUGE("file_store_capacity_bytes"),
     JOB_USAGE_BYTES_GAUGE("job_usage_bytes"),
 
-    BUILD_FAILED_TESTS("build_tests_failing");
+    BUILD_FAILED_TESTS("build_tests_failing"),
+
+    COVERAGE_CLASS_COVERED("coverage_class_covered"),
+    COVERAGE_CLASS_MISSED("coverage_class_missed"),
+    COVERAGE_CLASS_TOTAL("coverage_class_total"),
+
+    COVERAGE_BRANCH_COVERED("coverage_branch_covered"),
+    COVERAGE_BRANCH_MISSED("coverage_branch_missed"),
+    COVERAGE_BRANCH_TOTAL("coverage_branch_total"),
+
+    COVERAGE_INSTRUCTION_COVERED("coverage_instruction_covered"),
+    COVERAGE_INSTRUCTION_MISSED("coverage_instruction_missed"),
+    COVERAGE_INSTRUCTION_TOTAL("coverage_instruction_total"),
+
+    COVERAGE_FILE_COVERED("coverage_file_covered"),
+    COVERAGE_FILE_MISSED("coverage_file_missed"),
+    COVERAGE_FILE_TOTAL("coverage_file_total"),
+
+
+
+    ;
 
     private final String name;
 

src/main/java/org/jenkinsci/plugins/prometheus/collectors/coverage/CoverageBranchCoveredGauge.java

@@ -0,0 +1,45 @@
+package org.jenkinsci.plugins.prometheus.collectors.coverage;
+
+import edu.hm.hafner.coverage.Coverage;
+import edu.hm.hafner.coverage.Metric;
+import hudson.model.Run;
+import io.jenkins.plugins.coverage.metrics.model.Baseline;
+import io.prometheus.client.Gauge;
+import io.prometheus.client.SimpleCollector;
+import org.jenkinsci.plugins.prometheus.collectors.CollectorType;
+
+import java.util.Optional;
+
+public class CoverageBranchCoveredGauge extends CoverageMetricsCollector<Run<?, ?>, Gauge> {
+
+    protected CoverageBranchCoveredGauge(String[] labelNames, String namespace, String subsystem) {
+        super(labelNames, namespace, subsystem);
+    }
+
+    @Override
+    protected CollectorType getCollectorType() {
+        return CollectorType.COVERAGE_BRANCH_COVERED;
+    }
+
+    @Override
+    protected String getHelpText() {
+        return "Returns the number of branches covered";
+    }
+
+    @Override
+    protected SimpleCollector.Builder<?, Gauge> getCollectorBuilder() {
+        return Gauge.build();
+    }
+
+    @Override
+    public void calculateMetric(Run<?, ?> jenkinsObject, String[] labelValues) {
+
+        Optional<Coverage> optional = getCoverage(jenkinsObject, Metric.BRANCH, Baseline.PROJECT);
+        if (optional.isEmpty()) {
+            return;
+        }
+
+        Coverage coverage = optional.get();
+        collector.labels(labelValues).set(coverage.getCovered());
+    }
+}

src/main/java/org/jenkinsci/plugins/prometheus/collectors/coverage/CoverageBranchMissedGauge.java

@@ -0,0 +1,45 @@
+package org.jenkinsci.plugins.prometheus.collectors.coverage;
+
+import edu.hm.hafner.coverage.Coverage;
+import edu.hm.hafner.coverage.Metric;
+import hudson.model.Run;
+import io.jenkins.plugins.coverage.metrics.model.Baseline;
+import io.prometheus.client.Gauge;
+import io.prometheus.client.SimpleCollector;
+import org.jenkinsci.plugins.prometheus.collectors.CollectorType;
+
+import java.util.Optional;
+
+public class CoverageBranchMissedGauge extends CoverageMetricsCollector<Run<?, ?>, Gauge> {
+
+    protected CoverageBranchMissedGauge(String[] labelNames, String namespace, String subsystem) {
+        super(labelNames, namespace, subsystem);
+    }
+
+    @Override
+    protected CollectorType getCollectorType() {
+        return CollectorType.COVERAGE_BRANCH_MISSED;
+    }
+
+    @Override
+    protected String getHelpText() {
+        return "Returns the number of branches missed";
+    }
+
+    @Override
+    protected SimpleCollector.Builder<?, Gauge> getCollectorBuilder() {
+        return Gauge.build();
+    }
+
+    @Override
+    public void calculateMetric(Run<?, ?> jenkinsObject, String[] labelValues) {
+
+        Optional<Coverage> optional = getCoverage(jenkinsObject, Metric.BRANCH, Baseline.PROJECT);
+        if (optional.isEmpty()) {
+            return;
+        }
+
+        Coverage coverage = optional.get();
+        collector.labels(labelValues).set(coverage.getMissed());
+    }
+}

src/main/java/org/jenkinsci/plugins/prometheus/collectors/coverage/CoverageBranchTotalGauge.java

@@ -0,0 +1,45 @@
+package org.jenkinsci.plugins.prometheus.collectors.coverage;
+
+import edu.hm.hafner.coverage.Coverage;
+import edu.hm.hafner.coverage.Metric;
+import hudson.model.Run;
+import io.jenkins.plugins.coverage.metrics.model.Baseline;
+import io.prometheus.client.Gauge;
+import io.prometheus.client.SimpleCollector;
+import org.jenkinsci.plugins.prometheus.collectors.CollectorType;
+
+import java.util.Optional;
+
+public class CoverageBranchTotalGauge extends CoverageMetricsCollector<Run<?, ?>, Gauge> {
+
+    protected CoverageBranchTotalGauge(String[] labelNames, String namespace, String subsystem) {
+        super(labelNames, namespace, subsystem);
+    }
+
+    @Override
+    protected CollectorType getCollectorType() {
+        return CollectorType.COVERAGE_BRANCH_TOTAL;
+    }
+
+    @Override
+    protected String getHelpText() {
+        return "Returns the number of branches total";
+    }
+
+    @Override
+    protected SimpleCollector.Builder<?, Gauge> getCollectorBuilder() {
+        return Gauge.build();
+    }
+
+    @Override
+    public void calculateMetric(Run<?, ?> jenkinsObject, String[] labelValues) {
+
+        Optional<Coverage> optional = getCoverage(jenkinsObject, Metric.BRANCH, Baseline.PROJECT);
+        if (optional.isEmpty()) {
+            return;
+        }
+
+        Coverage coverage = optional.get();
+        collector.labels(labelValues).set(coverage.getTotal());
+    }
+}