Java tutorial
/* * Copyright 2015-2016 Netflix, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * */ package nebula.plugin.metrics.dispatcher; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.*; import com.fasterxml.jackson.databind.deser.BeanDeserializerModifier; import com.fasterxml.jackson.databind.module.SimpleModule; import com.fasterxml.jackson.databind.ser.std.StdSerializer; import com.fasterxml.jackson.datatype.joda.JodaModule; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Optional; import com.google.common.collect.Lists; import nebula.plugin.metrics.MetricsLoggerFactory; import nebula.plugin.metrics.MetricsPluginExtension; import nebula.plugin.metrics.model.*; import org.gradle.logging.internal.LogEvent; import org.slf4j.Logger; import java.io.IOException; import java.util.Collection; import java.util.List; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkNotNull; public abstract class AbstractMetricsDispatcher extends AbstractQueuedExecutionThreadService<Runnable> implements MetricsDispatcher { protected static final String BUILD_TYPE = "build"; protected static final String LOG_TYPE = "log"; protected final Logger logger = MetricsLoggerFactory.getLogger(this.getClass()); protected final MetricsPluginExtension extension; protected final ObjectMapper mapper; private final boolean async; private final Build build; protected Optional<String> buildId = Optional.absent(); @VisibleForTesting public static ObjectMapper getObjectMapper() { ObjectMapper mapper = new ObjectMapper(); mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false); mapper.registerModule(new JodaModule()); registerEnumModule(mapper); return mapper; } protected AbstractMetricsDispatcher(MetricsPluginExtension extension, boolean async) { super(extension.isFailOnError(), extension.isVerboseErrorOutput()); this.extension = checkNotNull(extension); this.mapper = getObjectMapper(); this.async = async; this.build = new Build(); } /** * Register Jackson module that maps enums as lowercase. Per http://stackoverflow.com/a/24173645. */ @SuppressWarnings("rawtypes") private static void registerEnumModule(ObjectMapper mapper) { SimpleModule module = new SimpleModule(); module.setDeserializerModifier(new BeanDeserializerModifier() { @Override public JsonDeserializer<Enum> modifyEnumDeserializer(DeserializationConfig config, final JavaType type, BeanDescription beanDesc, final JsonDeserializer<?> deserializer) { return new JsonDeserializer<Enum>() { @Override public Enum deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException { @SuppressWarnings("unchecked") Class<? extends Enum> rawClass = (Class<Enum<?>>) type.getRawClass(); return Enum.valueOf(rawClass, jp.getValueAsString().toUpperCase()); } }; } }); module.addSerializer(Enum.class, new StdSerializer<Enum>(Enum.class) { @Override public void serialize(Enum value, JsonGenerator jgen, SerializerProvider provider) throws IOException { jgen.writeString(value.name().toLowerCase()); } }); mapper.registerModule(module); } @Override protected final boolean isAsync() { return async; } @Override protected final void execute(Runnable runnable) throws Exception { runnable.run(); } @Override protected final void startUp() throws Exception { // This won't be accurate, but we at least want a value here if we have a failure that causes the duration not to be fired build.setStartTime(System.currentTimeMillis()); startUpClient(); initDatastore(); // indexBuildModel must be executed synchronously and block the service from continuing to "Running" state // because we want to record the state before the build started running. If we don't do this, we're risking // a race condition where the build finishes by the time the model is actually indexed. indexBuildModel(true); } @Override protected void postShutDown() throws Exception { shutDownClient(); } @Override protected void beforeShutDown() { // this indexBuildModel also must be executed synchronously or Gradle might kill the Service before // the dispatcher completes its work to upload the final build results. indexBuildModel(true); } @Override public Optional<String> receipt() { // by default, metrics dispatchers cannot provide a receipt. Concrete classes may change this behavior. return Optional.absent(); } private void indexBuildModel(boolean executeSynchronously) { Runnable runnable = new Runnable() { @Override public void run() { try { sanitizeProperties(build); Object transformed = transformBuild(build); String json = mapper.writeValueAsString(transformed); buildId = Optional.of(index(getBuildCollectionName(), BUILD_TYPE, json, buildId)); logger.info("Build id is {}", buildId.get()); } catch (JsonProcessingException e) { logger.error("Unable to write JSON string value", e); } } @Override public String toString() { return "AbstractMetricsDispatcher.indexBuildModel()"; } }; if (executeSynchronously) { executeSynchronously(runnable); } else { queue(runnable); } } /* * Override this method to transform the Build object into a different Build representation. For * example, when the Build format needs to be flattened out. */ protected Object transformBuild(Build build) { checkNotNull(build); return build; } private void sanitizeProperties(Build build) { Info info = build.getInfo(); if (info != null) { build.setInfo(Info.sanitize(info, extension.getSanitizedProperties())); } } @Override public final void started(Project project) { build.setProject(project); indexBuildModel(false); } @Override public final void duration(long startTime, long elapsedTime) { build.setStartTime(startTime); build.setElapsedTime(elapsedTime); } @Override public final void environment(Info info) { build.setInfo(info); } @Override public final void result(Result result) { build.setResult(result); } @Override public final void event(String description, String type, long elapsedTime) { build.addEvent(new Event(description, type, elapsedTime)); } @Override public final void task(Task task) { build.addTask(task); } @Override public final void test(Test test) { build.addTest(test); } @Override public void report(String reportName, Object report) { checkNotNull(reportName); checkNotNull(report); build.addBuildReport(reportName, report); } @Override public final void logEvent(final LogEvent event) { checkNotNull(event); Runnable runnable = new Runnable() { @Override public void run() { String json = renderEvent(event); index(getLogCollectionName(), LOG_TYPE, json, Optional.<String>absent()); } @Override public String toString() { return "AbstractMetricsDispatcher.logEvent()"; } }; queue(runnable); } @Override public final void logEvents(final Collection<LogEvent> events) { checkNotNull(events); checkArgument(!events.isEmpty(), "Empty events list found: %s", events); Runnable runnable = new Runnable() { @Override public void run() { List<String> jsons = Lists.newArrayListWithCapacity(events.size()); for (LogEvent event : events) { jsons.add(renderEvent(event)); } bulkIndex(getLogCollectionName(), LOG_TYPE, jsons); } @Override public String toString() { return "AbstractMetricsDispatcher.logEvents()"; } }; queue(runnable); } protected String renderEvent(LogEvent event) { return event.toString(); } protected void startUpClient() { // empty implementation. Concrete classes may override to add functionality. } protected void shutDownClient() { // empty implementation. Concrete classes may override to add functionality. } protected void initDatastore() { // empty implementation. Concrete classes may override to add functionality. } // the log collection name is where event log data gets uploaded to. // In Elastic this is the index name. In REST payloads it's the eventName. protected abstract String getLogCollectionName(); // the collection name is where the build data gets uploaded to. // In Elastic this is the index name. In REST payloads it's the eventName. protected abstract String getBuildCollectionName(); protected abstract String index(String indexName, String type, String source, Optional<String> id); protected abstract void bulkIndex(String indexName, String type, Collection<String> sources); }