Skip to content

JENKINS-55031 Feature toggles #104

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
wants to merge 3 commits into
base: development
Choose a base branch
from
Draft

JENKINS-55031 Feature toggles #104

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
94c6fc0
Extract functionality into a method per generator
darxriggs Oct 1, 2019
d2395f8
Consistent generator variable naming
darxriggs Oct 1, 2019
e0bbcc8
[JENKINS-55031] WIP Make it possible to enable/disable generators
darxriggs Oct 1, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
193 changes: 136 additions & 57 deletions src/main/java/jenkinsci/plugins/influxdb/InfluxDbPublicationService.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,12 +1,14 @@
package jenkinsci.plugins.influxdb;

import hudson.EnvVars;
import hudson.PluginWrapper;
import hudson.ProxyConfiguration;
import hudson.model.Run;
import hudson.model.TaskListener;
import hudson.util.Secret;
import jenkins.model.Jenkins;
import jenkinsci.plugins.influxdb.generators.*;
import jenkinsci.plugins.influxdb.models.DataToggles;
import jenkinsci.plugins.influxdb.models.Target;
import jenkinsci.plugins.influxdb.renderer.MeasurementRenderer;
import jenkinsci.plugins.influxdb.renderer.ProjectNameRenderer;
Expand All @@ -25,6 +27,7 @@
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;
import java.util.logging.Level;
import java.util.logging.Logger;

Expand Down Expand Up @@ -175,91 +178,157 @@ public void perform(Run<?, ?> build, TaskListener listener, EnvVars env) {
// Points to write
List<Point> pointsToWrite = new ArrayList<>();

// Basic metrics
JenkinsBasePointGenerator jGen = new JenkinsBasePointGenerator(measurementRenderer, customPrefix, build, timestamp, listener, jenkinsEnvParameterField, jenkinsEnvParameterTag, measurementName, env);
addPoints(pointsToWrite, jGen, listener);
generateJenkinsBaseData(build, listener, measurementRenderer, pointsToWrite, env);
generateCustomData1(build, listener, measurementRenderer, pointsToWrite);
generateCustomData2(build, listener, measurementRenderer, pointsToWrite);
generateCoberturaData(build, listener, measurementRenderer, pointsToWrite);
generateRobotFrameworkData(build, listener, measurementRenderer, pointsToWrite);
generateJacocoData(build, listener, measurementRenderer, pointsToWrite);
generatePerformanceData(build, listener, measurementRenderer, pointsToWrite);
generateSonarQubeData(build, listener, measurementRenderer, pointsToWrite, env);
generateChangeLogData(build, listener, measurementRenderer, pointsToWrite);
generatePerfPublisherData(build, listener, measurementRenderer, pointsToWrite);

CustomDataPointGenerator cdGen = new CustomDataPointGenerator(measurementRenderer, customPrefix, build, timestamp, customData, customDataTags, measurementName);
if (cdGen.hasReport()) {
for (Target target : selectedTargets) {
String logMessage = "[InfluxDB Plugin] Publishing data to: " + target;
logger.log(Level.FINE, logMessage);
listener.getLogger().println(logMessage);

URL url;
try {
url = new URL(target.getUrl());
} catch (MalformedURLException e) {
listener.getLogger().println("[InfluxDB Plugin] Skipping target due to invalid URL: " + target.getUrl());
continue;
}

OkHttpClient.Builder httpClient = createHttpClient(url, target.isUsingJenkinsProxy());
InfluxDB influxDB = StringUtils.isEmpty(target.getUsername()) ?
InfluxDBFactory.connect(target.getUrl(), httpClient) :
InfluxDBFactory.connect(target.getUrl(), target.getUsername(), Secret.toString(target.getPassword()), httpClient);
writeToInflux(target, influxDB, pointsToWrite);
}

listener.getLogger().println("[InfluxDB Plugin] Completed.");
}

private void generateJenkinsBaseData(Run<?, ?> build, TaskListener listener, MeasurementRenderer<Run<?, ?>> measurementRenderer, List<Point> pointsToWrite, EnvVars env) {
JenkinsBasePointGenerator generator = new JenkinsBasePointGenerator(measurementRenderer, customPrefix, build, timestamp, listener, jenkinsEnvParameterField, jenkinsEnvParameterTag, measurementName, env);
addPoints(pointsToWrite, generator, listener);
}

private void generateCustomData1(Run<?, ?> build, TaskListener listener, MeasurementRenderer<Run<?, ?>> measurementRenderer, List<Point> pointsToWrite) {
CustomDataPointGenerator generator = new CustomDataPointGenerator(measurementRenderer, customPrefix, build, timestamp, customData, customDataTags, measurementName);
if (generator.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] Custom data found. Writing to InfluxDB...");
addPoints(pointsToWrite, cdGen, listener);
addPoints(pointsToWrite, generator, listener);
} else {
logger.log(Level.FINE, "Data source empty: Custom Data");
}
}

CustomDataMapPointGenerator cdmGen = new CustomDataMapPointGenerator(measurementRenderer, customPrefix, build, timestamp, customDataMap, customDataMapTags);
if (cdmGen.hasReport()) {
private void generateCustomData2(Run<?, ?> build, TaskListener listener, MeasurementRenderer<Run<?, ?>> measurementRenderer, List<Point> pointsToWrite) {
CustomDataMapPointGenerator generator = new CustomDataMapPointGenerator(measurementRenderer, customPrefix, build, timestamp, customDataMap, customDataMapTags);
if (generator.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] Custom data map found. Writing to InfluxDB...");
addPoints(pointsToWrite, cdmGen, listener);
addPoints(pointsToWrite, generator, listener);
} else {
logger.log(Level.FINE, "Data source empty: Custom Data Map");
}
}

try {
CoberturaPointGenerator cGen = new CoberturaPointGenerator(measurementRenderer, customPrefix, build, timestamp);
if (cGen.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] Cobertura data found. Writing to InfluxDB...");
addPoints(pointsToWrite, cGen, listener);
private void generateCoberturaData(Run<?, ?> build, TaskListener listener, MeasurementRenderer<Run<?, ?>> measurementRenderer, List<Point> pointsToWrite) {
if (isCollectData("cobertura", DataToggles::isCobertura)) {
try {
CoberturaPointGenerator generator = new CoberturaPointGenerator(measurementRenderer, customPrefix, build, timestamp);
if (generator.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] Cobertura data found. Writing to InfluxDB...");
addPoints(pointsToWrite, generator, listener);
}
} catch (NoClassDefFoundError ignore) {
logger.log(Level.FINE, "Plugin skipped: Cobertura");
}
} catch (NoClassDefFoundError ignore) {
logger.log(Level.FINE, "Plugin skipped: Cobertura");
}
}

try {
RobotFrameworkPointGenerator rfGen = new RobotFrameworkPointGenerator(measurementRenderer, customPrefix, build, timestamp);
if (rfGen.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] Robot Framework data found. Writing to InfluxDB...");
addPoints(pointsToWrite, rfGen, listener);
private void generateRobotFrameworkData(Run<?, ?> build, TaskListener listener, MeasurementRenderer<Run<?, ?>> measurementRenderer, List<Point> pointsToWrite) {
if (isCollectData("robot", DataToggles::isRobotFramework)) {
try {
RobotFrameworkPointGenerator generator = new RobotFrameworkPointGenerator(measurementRenderer, customPrefix, build, timestamp);
if (generator.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] Robot Framework data found. Writing to InfluxDB...");
addPoints(pointsToWrite, generator, listener);
}
} catch (NoClassDefFoundError ignore) {
logger.log(Level.FINE, "Plugin skipped: Robot Framework");
}
} catch (NoClassDefFoundError ignore) {
logger.log(Level.FINE, "Plugin skipped: Robot Framework");
}
}

try {
JacocoPointGenerator jacoGen = new JacocoPointGenerator(measurementRenderer, customPrefix, build, timestamp);
if (jacoGen.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] JaCoCo data found. Writing to InfluxDB...");
addPoints(pointsToWrite, jacoGen, listener);
private void generateJacocoData(Run<?, ?> build, TaskListener listener, MeasurementRenderer<Run<?, ?>> measurementRenderer, List<Point> pointsToWrite) {
if (isCollectData("jacoco", DataToggles::isJacoco)) {
try {
JacocoPointGenerator generator = new JacocoPointGenerator(measurementRenderer, customPrefix, build, timestamp);
if (generator.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] JaCoCo data found. Writing to InfluxDB...");
addPoints(pointsToWrite, generator, listener);
}
} catch (NoClassDefFoundError ignore) {
logger.log(Level.FINE, "Plugin skipped: JaCoCo");
}
} catch (NoClassDefFoundError ignore) {
logger.log(Level.FINE, "Plugin skipped: JaCoCo");
}
}

try {
PerformancePointGenerator perfGen = new PerformancePointGenerator(measurementRenderer, customPrefix, build, timestamp);
if (perfGen.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] Performance data found. Writing to InfluxDB...");
addPoints(pointsToWrite, perfGen, listener);
private void generatePerformanceData(Run<?, ?> build, TaskListener listener, MeasurementRenderer<Run<?, ?>> measurementRenderer, List<Point> pointsToWrite) {
if (isCollectData("performance", DataToggles::isPerformance)) {
try {
PerformancePointGenerator generator = new PerformancePointGenerator(measurementRenderer, customPrefix, build, timestamp);
if (generator.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] Performance data found. Writing to InfluxDB...");
addPoints(pointsToWrite, generator, listener);
}
} catch (NoClassDefFoundError ignore) {
logger.log(Level.FINE, "Plugin skipped: Performance");
}
} catch (NoClassDefFoundError ignore) {
logger.log(Level.FINE, "Plugin skipped: Performance");
}
}

SonarQubePointGenerator sonarGen = new SonarQubePointGenerator(measurementRenderer, customPrefix, build, timestamp, listener);
if (sonarGen.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] SonarQube data found. Writing to InfluxDB...");
sonarGen.setEnv(env);
addPoints(pointsToWrite, sonarGen, listener);
} else {
logger.log(Level.FINE, "Plugin skipped: SonarQube");
private void generateSonarQubeData(Run<?, ?> build, TaskListener listener, MeasurementRenderer<Run<?, ?>> measurementRenderer, List<Point> pointsToWrite, EnvVars env) {
if (isCollectData(null, DataToggles::isSonarqube)) {
SonarQubePointGenerator generator = new SonarQubePointGenerator(measurementRenderer, customPrefix, build, timestamp, listener);
if (generator.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] SonarQube data found. Writing to InfluxDB...");
generator.setEnv(env);
addPoints(pointsToWrite, generator, listener);
} else {
logger.log(Level.FINE, "Plugin skipped: SonarQube");
}
}
}

ChangeLogPointGenerator changeLogGen = new ChangeLogPointGenerator(measurementRenderer, customPrefix, build, timestamp);
if (changeLogGen.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] Change Log data found. Writing to InfluxDB...");
addPoints(pointsToWrite, changeLogGen, listener);
} else {
logger.log(Level.FINE, "Data source empty: Change Log");
private void generateChangeLogData(Run<?, ?> build, TaskListener listener, MeasurementRenderer<Run<?, ?>> measurementRenderer, List<Point> pointsToWrite) {
if (isCollectData(null, DataToggles::isChangelog)) {
ChangeLogPointGenerator generator = new ChangeLogPointGenerator(measurementRenderer, customPrefix, build, timestamp);
if (generator.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] Change Log data found. Writing to InfluxDB...");
addPoints(pointsToWrite, generator, listener);
} else {
logger.log(Level.FINE, "Data source empty: Change Log");
}
}
}

try {
PerfPublisherPointGenerator perfPublisherGen = new PerfPublisherPointGenerator(measurementRenderer, customPrefix, build, timestamp);
if (perfPublisherGen.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] Performance Publisher data found. Writing to InfluxDB...");
addPoints(pointsToWrite, perfPublisherGen, listener);
private void generatePerfPublisherData(Run<?, ?> build, TaskListener listener, MeasurementRenderer<Run<?, ?>> measurementRenderer, List<Point> pointsToWrite) {
if (isCollectData("perfpublisher", DataToggles::isPerfPublisher)) {
try {
PerfPublisherPointGenerator generator = new PerfPublisherPointGenerator(measurementRenderer, customPrefix, build, timestamp);
if (generator.hasReport()) {
listener.getLogger().println("[InfluxDB Plugin] Performance Publisher data found. Writing to InfluxDB...");
addPoints(pointsToWrite, generator, listener);
}
} catch (NoClassDefFoundError ignore) {
logger.log(Level.FINE, "Plugin skipped: Performance Publisher");
}
} catch (NoClassDefFoundError ignore) {
logger.log(Level.FINE, "Plugin skipped: Performance Publisher");
}

for (Target target : selectedTargets) {
Expand Down Expand Up @@ -301,6 +370,16 @@ private void addPoints(List<Point> pointsToWrite, PointGenerator generator, Task
}
}

private boolean isCollectData(String pluginName, Predicate<DataToggles> isEnabled) {
if (pluginName != null) {
PluginWrapper plugin = Jenkins.getInstance().getPluginManager().getPlugin(pluginName);
if (plugin == null || !plugin.isActive()) {
return false;
}
}
return selectedTargets.stream().map(Target::getData).anyMatch(isEnabled);
}

private OkHttpClient.Builder createHttpClient(URL url, boolean useProxy) {
OkHttpClient.Builder builder = httpClient.newBuilder();
ProxyConfiguration proxyConfig = Jenkins.getInstance().proxy;
Expand Down
101 changes: 101 additions & 0 deletions src/main/java/jenkinsci/plugins/influxdb/models/DataToggles.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,101 @@
package jenkinsci.plugins.influxdb.models;

import hudson.Extension;
import hudson.model.AbstractDescribableImpl;
import hudson.model.Descriptor;
import jenkinsci.plugins.influxdb.generators.*;
import org.kohsuke.stapler.DataBoundConstructor;
import org.kohsuke.stapler.DataBoundSetter;

public class DataToggles extends AbstractDescribableImpl<DataToggles> implements java.io.Serializable {

/** @see CoberturaPointGenerator */
private boolean cobertura = true;

/** @see RobotFrameworkPointGenerator */
private boolean robotFramework = true;

/** @see JacocoPointGenerator */
private boolean jacoco = true;

/** @see PerformancePointGenerator */
private boolean performance = true;

/** @see SonarQubePointGenerator */
private boolean sonarqube = true;

/** @see ChangeLogPointGenerator */
private boolean changelog = true;

/** @see PerfPublisherPointGenerator */
private boolean perfPublisher = true;

@DataBoundConstructor
public DataToggles() {}

public boolean isCobertura() {
return cobertura;
}

@DataBoundSetter
public void setCobertura(boolean cobertura) {
this.cobertura = cobertura;
}

public boolean isRobotFramework() {
return robotFramework;
}

@DataBoundSetter
public void setRobotFramework(boolean robotFramework) {
this.robotFramework = robotFramework;
}

public boolean isJacoco() {
return jacoco;
}

@DataBoundSetter
public void setJacoco(boolean jacoco) {
this.jacoco = jacoco;
}

public boolean isPerformance() {
return performance;
}

@DataBoundSetter
public void setPerformance(boolean performance) {
this.performance = performance;
}

public boolean isSonarqube() {
return sonarqube;
}

@DataBoundSetter
public void setSonarqube(boolean sonarqube) {
this.sonarqube = sonarqube;
}

public boolean isChangelog() {
return changelog;
}

@DataBoundSetter
public void setChangelog(boolean changelog) {
this.changelog = changelog;
}

public boolean isPerfPublisher() {
return perfPublisher;
}

@DataBoundSetter
public void setPerfPublisher(boolean perfPublisher) {
this.perfPublisher = perfPublisher;
}

@Extension
public static class DescriptorImpl extends Descriptor<DataToggles> {}
}
Loading