Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
// 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;
import com.google.auto.value.AutoValue;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.flogger.FluentLogger;
import com.google.gerrit.entities.Account;
import com.google.gerrit.server.config.GerritServerConfig;
import com.google.gerrit.server.logging.RequestId;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import java.util.Optional;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.lib.Config;
/**
* Request listener that sets additional logging tags and enables tracing automatically if the
* request matches any tracing configuration in gerrit.config (see description of
* 'tracing.' subsection in config-gerrit.txt).
*/
@Singleton
public class TraceRequestListener implements RequestListener {
private static final FluentLogger logger = FluentLogger.forEnclosingClass();
private final Config cfg;
private final ImmutableList traceConfigs;
@Inject
TraceRequestListener(@GerritServerConfig Config cfg) {
this.cfg = cfg;
this.traceConfigs = parseTraceConfigs();
}
@Override
public void onRequest(RequestInfo requestInfo) {
requestInfo.project().ifPresent(p -> requestInfo.traceContext().addTag("project", p));
traceConfigs.stream()
.filter(traceConfig -> traceConfig.matches(requestInfo))
.forEach(
traceConfig ->
requestInfo
.traceContext()
.forceLogging()
.addTag(RequestId.Type.TRACE_ID, traceConfig.traceId()));
}
private ImmutableList parseTraceConfigs() {
ImmutableList.Builder traceConfigs = ImmutableList.builder();
for (String traceId : cfg.getSubsections("tracing")) {
try {
TraceConfig.Builder traceConfig = TraceConfig.builder();
traceConfig.traceId(traceId);
traceConfig.requestTypes(parseRequestTypes(traceId));
traceConfig.requestUriPatterns(parseRequestUriPatterns(traceId));
traceConfig.accountIds(parseAccounts(traceId));
traceConfig.projectPatterns(parseProjectPatterns(traceId));
traceConfigs.add(traceConfig.build());
} catch (ConfigInvalidException e) {
logger.atWarning().log("Ignoring invalid tracing configuration:\n %s", e.getMessage());
}
}
return traceConfigs.build();
}
private ImmutableSet parseRequestTypes(String traceId) {
return ImmutableSet.copyOf(cfg.getStringList("tracing", traceId, "requestType"));
}
private ImmutableSet parseRequestUriPatterns(String traceId)
throws ConfigInvalidException {
return parsePatterns(traceId, "requestUriPattern");
}
private ImmutableSet parseAccounts(String traceId) throws ConfigInvalidException {
ImmutableSet.Builder accountIds = ImmutableSet.builder();
String[] accounts = cfg.getStringList("tracing", traceId, "account");
for (String account : accounts) {
Optional accountId = Account.Id.tryParse(account);
if (!accountId.isPresent()) {
throw new ConfigInvalidException(
String.format(
"Invalid tracing config ('tracing.%s.account = %s'): invalid account ID",
traceId, account));
}
accountIds.add(accountId.get());
}
return accountIds.build();
}
private ImmutableSet parseProjectPatterns(String traceId) throws ConfigInvalidException {
return parsePatterns(traceId, "projectPattern");
}
private ImmutableSet parsePatterns(String traceId, String name)
throws ConfigInvalidException {
ImmutableSet.Builder patterns = ImmutableSet.builder();
String[] patternRegExs = cfg.getStringList("tracing", traceId, name);
for (String patternRegEx : patternRegExs) {
try {
patterns.add(Pattern.compile(patternRegEx));
} catch (PatternSyntaxException e) {
throw new ConfigInvalidException(
String.format(
"Invalid tracing config ('tracing.%s.%s = %s'): %s",
traceId, name, patternRegEx, e.getMessage()));
}
}
return patterns.build();
}
@AutoValue
abstract static class TraceConfig {
/** ID for the trace */
abstract String traceId();
/** request types that should be traced */
abstract ImmutableSet requestTypes();
/** pattern matching request URIs */
abstract ImmutableSet requestUriPatterns();
/** accounts IDs matching calling user */
abstract ImmutableSet accountIds();
/** pattern matching projects names */
abstract ImmutableSet projectPatterns();
static Builder builder() {
return new AutoValue_TraceRequestListener_TraceConfig.Builder();
}
/**
* Whether this trace config matches a given request.
*
* @param requestInfo request info
* @return whether this trace config matches
*/
boolean matches(RequestInfo requestInfo) {
// If in the trace config request types are set and none of them matches, then the request is
// not matched.
if (!requestTypes().isEmpty()
&& requestTypes().stream()
.noneMatch(type -> type.equalsIgnoreCase(requestInfo.requestType()))) {
return false;
}
// If in the trace config request URI patterns are set and none of them matches, then the
// request is not matched.
if (!requestUriPatterns().isEmpty()) {
if (!requestInfo.requestUri().isPresent()) {
// The request has no request URI, hence it cannot match a request URI pattern.
return false;
}
if (requestUriPatterns().stream()
.noneMatch(p -> p.matcher(requestInfo.requestUri().get()).matches())) {
return false;
}
}
// If in the trace config accounts are set and none of them matches, then the request is not
// matched.
if (!accountIds().isEmpty()) {
try {
if (accountIds().stream()
.noneMatch(id -> id.equals(requestInfo.callingUser().getAccountId()))) {
return false;
}
} catch (UnsupportedOperationException e) {
// The calling user is not logged in, hence it cannot match an account.
return false;
}
}
// If in the trace config project patterns are set and none of them matches, then the request
// is not matched.
if (!projectPatterns().isEmpty()) {
if (!requestInfo.project().isPresent()) {
// The request is not for a project, hence it cannot match a project pattern.
return false;
}
if (projectPatterns().stream()
.noneMatch(p -> p.matcher(requestInfo.project().get().get()).matches())) {
return false;
}
}
// For any match criteria (request type, request URI pattern, account, project pattern) that
// was specified in the trace config, at least one of the configured value matched the
// request.
return true;
}
@AutoValue.Builder
abstract static class Builder {
abstract Builder traceId(String traceId);
abstract Builder requestTypes(ImmutableSet requestTypes);
abstract Builder requestUriPatterns(ImmutableSet requestUriPatterns);
abstract Builder accountIds(ImmutableSet accountIds);
abstract Builder projectPatterns(ImmutableSet projectPatterns);
abstract TraceConfig build();
}
}
}
