blob: 90e716f9a383e45579f4da5da3ba82bf8bb4f080 [file] [log] [blame]
// Copyright (C) 2019 The Android Open Source Project
//
// 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 com.google.gerrit.server.logging;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.flogger.FluentLogger;
import com.google.gerrit.extensions.registration.DynamicSet;
import com.google.gerrit.extensions.registration.Extension;
import org.eclipse.jgit.lib.Config;
/**
* Context for capturing performance log records. When the context is closed the performance log
* records are handed over to the registered {@link PerformanceLogger}s.
*
* <p>Capturing performance log records is disabled if there are no {@link PerformanceLogger}
* registered (in this case the captured performance log records would never be used).
*
* <p>It's important to enable capturing of performance log records in a context that ensures to
* consume the captured performance log records. Otherwise captured performance log records might
* leak into other requests that are executed by the same thread (if a thread pool is used to
* process requests).
*/
public class PerformanceLogContext implements AutoCloseable {
private static final FluentLogger logger = FluentLogger.forEnclosingClass();
// Do not use PluginSetContext. PluginSetContext traces the plugin latency with a timer metric
// which would result in a performance log and we don't want to log the performance of writing
// a performance log in the performance log (endless loop).
private final DynamicSet<PerformanceLogger> performanceLoggers;
private final boolean oldPerformanceLogging;
private final ImmutableList<PerformanceLogRecord> oldPerformanceLogRecords;
public PerformanceLogContext(
Config gerritConfig, DynamicSet<PerformanceLogger> performanceLoggers) {
this.performanceLoggers = performanceLoggers;
// Just in case remember the old state and reset performance log entries.
this.oldPerformanceLogging = LoggingContext.getInstance().isPerformanceLogging();
this.oldPerformanceLogRecords = LoggingContext.getInstance().getPerformanceLogRecords();
LoggingContext.getInstance().clearPerformanceLogEntries();
// Do not create performance log entries if performance logging is disabled or if no
// PerformanceLogger is registered.
boolean enablePerformanceLogging =
gerritConfig.getBoolean("tracing", "performanceLogging", false);
LoggingContext.getInstance()
.performanceLogging(
enablePerformanceLogging && !Iterables.isEmpty(performanceLoggers.entries()));
}
@Override
public void close() {
if (LoggingContext.getInstance().isPerformanceLogging()) {
runEach(performanceLoggers, LoggingContext.getInstance().getPerformanceLogRecords());
}
// Restore old state. Required to support nesting of PerformanceLogContext's.
LoggingContext.getInstance().performanceLogging(oldPerformanceLogging);
LoggingContext.getInstance().setPerformanceLogRecords(oldPerformanceLogRecords);
}
/**
* Invokes all performance loggers.
*
* <p>Similar to how {@code com.google.gerrit.server.plugincontext.PluginContext} invokes plugins
* but without recording metrics for invoking {@link PerformanceLogger}s.
*
* @param performanceLoggers the performance loggers that should be invoked
* @param performanceLogRecords the performance log records that should be handed over to the
* performance loggers
*/
private static void runEach(
DynamicSet<PerformanceLogger> performanceLoggers,
ImmutableList<PerformanceLogRecord> performanceLogRecords) {
performanceLoggers
.entries()
.forEach(
p -> {
try (TraceContext traceContext = newPluginTrace(p)) {
performanceLogRecords.forEach(r -> r.writeTo(p.get()));
} catch (RuntimeException e) {
logger.atWarning().withCause(e).log(
"Failure in %s of plugin %s", p.get().getClass(), p.getPluginName());
}
});
}
/**
* Opens a trace context for a plugin that implements {@link PerformanceLogger}.
*
* <p>Basically the same as {@code
* com.google.gerrit.server.plugincontext.PluginContext#newTrace(Extension<T>)}. We have this
* method here to avoid a dependency on PluginContext which lives in
* "//java/com/google/gerrit/server". This package ("//java/com/google/gerrit/server/logging")
* should have as few dependencies as possible.
*
* @param extension performance logger extension
* @return the trace context
*/
private static TraceContext newPluginTrace(Extension<PerformanceLogger> extension) {
return TraceContext.open().addPluginTag(extension.getPluginName());
}
}