diff --git a/dubbo-common/src/main/java/org/apache/dubbo/common/logger/FluentLogger.java b/dubbo-common/src/main/java/org/apache/dubbo/common/logger/FluentLogger.java new file mode 100644 index 000000000000..4842e5d83cc4 --- /dev/null +++ b/dubbo-common/src/main/java/org/apache/dubbo/common/logger/FluentLogger.java @@ -0,0 +1,124 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.dubbo.common.logger; + +import java.util.function.Supplier; + +public interface FluentLogger { + + FluentLogger cause(String cause); + + FluentLogger more(String extendedInformation); + + FluentLogger msg(String msg); + + FluentLogger msg(String msg, Object... args); + + FluentLogger msg(Supplier supplier); + + void trace(); + + void trace(Throwable t); + + void trace(String msg); + + void trace(String msg, Object... args); + + void trace(String msg, Throwable t); + + void debug(); + + void debug(Throwable t); + + void debug(String msg); + + void debug(String msg, Object... args); + + void debug(String msg, Throwable t); + + void info(); + + void info(Throwable t); + + void info(String msg, Object... args); + + void info(String msg); + + void info(String msg, Throwable t); + + void internalWarn(); + + void internalWarn(Throwable t); + + void internalWarn(String msg); + + void internalWarn(String msg, Object... args); + + void internalWarn(String msg, Throwable t); + + void warn(String code, String msg, Object... args); + + void warn(String code, String msg, Throwable t); + + void internalError(); + + void internalError(Throwable t); + + void internalError(String msg); + + void internalError(String msg, Object... args); + + void internalError(String msg, Throwable t); + + void error(String code, String msg, Object... args); + + void error(String code, String msg, Throwable t); + + void log(Level level); + + void log(Level level, Throwable t); + + void log(Level level, String msg); + + void log(Level level, String msg, Object... args); + + void log(Level level, String msg, Throwable t); + + void log(Level level, String code, String msg, Object... args); + + void log(Level level, String code, String msg, Throwable t); + + boolean isTraceEnabled(); + + boolean isDebugEnabled(); + + boolean isInfoEnabled(); + + boolean isWarnEnabled(); + + boolean isErrorEnabled(); + + static FluentLogger of(Class key) { + return new FluentLoggerImpl(key); + } + + static FluentLogger of(String key) { + return new FluentLoggerImpl(key); + } + + interface S extends Supplier {} +} diff --git a/dubbo-common/src/main/java/org/apache/dubbo/common/logger/FluentLoggerImpl.java b/dubbo-common/src/main/java/org/apache/dubbo/common/logger/FluentLoggerImpl.java new file mode 100644 index 000000000000..fac91a16eea9 --- /dev/null +++ b/dubbo-common/src/main/java/org/apache/dubbo/common/logger/FluentLoggerImpl.java @@ -0,0 +1,621 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.dubbo.common.logger; + +import org.apache.dubbo.common.logger.helpers.FormattingTuple; +import org.apache.dubbo.common.logger.helpers.MessageFormatter; +import org.apache.dubbo.common.utils.StringUtils; + +import java.util.function.Supplier; + +import static org.apache.dubbo.common.constants.LoggerCodeConstants.INTERNAL_ERROR; + +final class FluentLoggerImpl implements FluentLogger { + + private final ErrorTypeAwareLogger delegate; + private final FluentLoggerImpl root; + + private String cause = StringUtils.EMPTY_STRING; + private String extendedInformation = StringUtils.EMPTY_STRING; + private Supplier messageSupplier; + private String message; + private Object[] args; + + FluentLoggerImpl(Class key) { + delegate = LoggerFactory.getErrorTypeAwareLogger(key); + root = this; + } + + FluentLoggerImpl(String key) { + delegate = LoggerFactory.getErrorTypeAwareLogger(key); + root = this; + } + + private FluentLoggerImpl(FluentLoggerImpl logger) { + delegate = logger.delegate; + root = logger; + } + + @Override + public FluentLogger cause(String cause) { + if (cause == null) { + return this; + } + FluentLoggerImpl logger = getLogger(); + logger.cause = cause; + return logger; + } + + @Override + public FluentLogger more(String extendedInformation) { + if (extendedInformation == null) { + return this; + } + FluentLoggerImpl logger = getLogger(); + logger.extendedInformation = extendedInformation; + return logger; + } + + @Override + public FluentLogger msg(String message) { + FluentLoggerImpl logger = getLogger(); + logger.message = message; + return logger; + } + + @Override + public FluentLogger msg(String message, Object... args) { + FluentLoggerImpl logger = getLogger(); + logger.message = message; + logger.args = args; + return logger; + } + + @Override + public FluentLogger msg(Supplier supplier) { + FluentLoggerImpl logger = getLogger(); + logger.messageSupplier = supplier; + return logger; + } + + @Override + public void trace() { + if (message != null) { + if (args != null && args.length > 0) { + if (delegate.isTraceEnabled()) { + delegate.trace(message, formatArgs(args)); + } + } else { + delegate.trace(message); + } + } else if (messageSupplier != null) { + if (delegate.isTraceEnabled()) { + delegate.trace(messageSupplier.get()); + } + } else { + warnMessageMissing(); + } + } + + @Override + public void trace(Throwable t) { + if (message != null) { + int len = args == null ? 0 : args.length; + if (len > 0) { + if (delegate.isTraceEnabled()) { + Object[] arr = new Object[len + 1]; + System.arraycopy(args, 0, arr, 0, len); + arr[len] = t; + delegate.trace(message, formatArgs(arr)); + } + } else { + delegate.trace(message, t); + } + } else if (messageSupplier != null) { + if (delegate.isTraceEnabled()) { + delegate.trace(messageSupplier.get(), t); + } + } else { + warnMessageMissing(); + } + } + + @Override + public void trace(String message) { + delegate.trace(message); + } + + @Override + public void trace(String message, Object... args) { + if (args == null) { + delegate.trace(message); + } else { + delegate.trace(message, formatArgs(args)); + } + } + + @Override + public void trace(String message, Throwable t) { + delegate.trace(message, t); + } + + @Override + public void debug() { + if (message != null) { + if (args != null && args.length > 0) { + if (delegate.isDebugEnabled()) { + delegate.debug(message, formatArgs(args)); + } + } else { + delegate.debug(message); + } + } else if (messageSupplier != null) { + if (delegate.isDebugEnabled()) { + delegate.debug(messageSupplier.get()); + } + } else { + warnMessageMissing(); + } + } + + @Override + public void debug(Throwable t) { + if (message != null) { + int len = args == null ? 0 : args.length; + if (len > 0) { + if (delegate.isDebugEnabled()) { + Object[] arr = new Object[len + 1]; + System.arraycopy(args, 0, arr, 0, len); + arr[len] = t; + delegate.debug(message, formatArgs(arr)); + } + } else { + delegate.debug(message, t); + } + } else if (messageSupplier != null) { + if (delegate.isDebugEnabled()) { + delegate.debug(messageSupplier.get(), t); + } + } else { + warnMessageMissing(); + } + } + + @Override + public void debug(String message) { + delegate.debug(message); + } + + @Override + public void debug(String message, Object... args) { + if (args == null) { + delegate.debug(message); + } else { + delegate.debug(message, formatArgs(args)); + } + } + + @Override + public void debug(String message, Throwable t) { + delegate.debug(message, t); + } + + @Override + public void info() { + if (message != null) { + if (args != null && args.length > 0) { + delegate.info(message, formatArgs(args)); + } else { + delegate.info(message); + } + } else if (messageSupplier != null) { + if (delegate.isInfoEnabled()) { + delegate.info(messageSupplier.get()); + } + } else { + warnMessageMissing(); + } + } + + @Override + public void info(Throwable t) { + if (message != null) { + int len = args == null ? 0 : args.length; + if (len > 0) { + Object[] arr = new Object[len + 1]; + System.arraycopy(args, 0, arr, 0, len); + arr[len] = t; + delegate.info(message, formatArgs(arr)); + } else { + delegate.info(message, t); + } + } else if (messageSupplier != null) { + if (delegate.isInfoEnabled()) { + delegate.info(messageSupplier.get(), t); + } + } else { + warnMessageMissing(); + } + } + + @Override + public void info(String message, Object... args) { + if (args == null) { + delegate.info(message); + } else { + delegate.info(message, formatArgs(args)); + } + } + + @Override + public void info(String message) { + delegate.info(message); + } + + @Override + public void info(String message, Throwable t) { + delegate.info(message, t); + } + + @Override + public void internalWarn() { + if (message != null) { + if (args != null && args.length > 0) { + formatAndWarn(INTERNAL_ERROR, message, args); + } else { + delegate.warn(INTERNAL_ERROR, cause, extendedInformation, message); + } + } else if (messageSupplier != null) { + if (delegate.isWarnEnabled()) { + delegate.warn(INTERNAL_ERROR, cause, extendedInformation, messageSupplier.get()); + } + } else { + warnMessageMissing(); + } + } + + @Override + public void internalWarn(Throwable t) { + if (message != null) { + if (args != null && args.length > 0) { + if (delegate.isWarnEnabled()) { + FormattingTuple tuple = MessageFormatter.arrayFormat(message, formatArgs(args)); + delegate.warn(INTERNAL_ERROR, cause, extendedInformation, tuple.getMessage(), t); + } + } else { + delegate.warn(INTERNAL_ERROR, cause, extendedInformation, message, t); + } + } else if (messageSupplier != null && delegate.isWarnEnabled()) { + delegate.warn(INTERNAL_ERROR, cause, extendedInformation, messageSupplier.get(), t); + } + } + + @Override + public void internalWarn(String message) { + warn(INTERNAL_ERROR, message); + } + + @Override + public void internalWarn(String message, Object... args) { + warn(INTERNAL_ERROR, message, args); + } + + @Override + public void internalWarn(String message, Throwable t) { + warn(INTERNAL_ERROR, message, t); + } + + @Override + public void warn(String code, String message, Object... args) { + if (args == null || args.length == 0) { + delegate.warn(code, cause, extendedInformation, message); + return; + } + formatAndWarn(code, message, args); + } + + private void formatAndWarn(String code, String message, Object... args) { + if (!delegate.isWarnEnabled()) { + return; + } + FormattingTuple tuple = MessageFormatter.arrayFormat(message, formatArgs(args)); + if (tuple.getThrowable() == null) { + delegate.warn(code, cause, extendedInformation, tuple.getMessage()); + } else { + delegate.warn(code, cause, extendedInformation, tuple.getMessage(), tuple.getThrowable()); + } + } + + @Override + public void warn(String code, String message, Throwable t) { + delegate.warn(code, cause, extendedInformation, message, t); + } + + @Override + public void internalError() { + if (message != null) { + if (args != null && args.length > 0) { + formatAndError(INTERNAL_ERROR, message, args); + } else { + delegate.error(INTERNAL_ERROR, cause, extendedInformation, message); + } + } else if (messageSupplier != null) { + if (delegate.isErrorEnabled()) { + delegate.error(INTERNAL_ERROR, cause, extendedInformation, messageSupplier.get()); + } + } else { + warnMessageMissing(); + } + } + + private void formatAndError(String code, String message, Object... args) { + if (!delegate.isErrorEnabled()) { + return; + } + FormattingTuple tuple = MessageFormatter.arrayFormat(message, formatArgs(args)); + if (tuple.getThrowable() == null) { + delegate.error(code, cause, extendedInformation, tuple.getMessage()); + } else { + delegate.error(code, cause, extendedInformation, tuple.getMessage(), tuple.getThrowable()); + } + } + + @Override + public void internalError(Throwable t) { + if (message != null) { + if (args != null && args.length > 0) { + if (delegate.isErrorEnabled()) { + FormattingTuple tuple = MessageFormatter.arrayFormat(message, formatArgs(args)); + delegate.error(INTERNAL_ERROR, cause, extendedInformation, tuple.getMessage(), t); + } + } else { + delegate.error(INTERNAL_ERROR, cause, extendedInformation, message, t); + } + } else if (messageSupplier != null) { + if (delegate.isErrorEnabled()) { + delegate.error(INTERNAL_ERROR, cause, extendedInformation, messageSupplier.get(), t); + } + } else { + warnMessageMissing(); + } + } + + @Override + public void internalError(String message) { + error(INTERNAL_ERROR, message); + } + + @Override + public void internalError(String message, Object... args) { + error(INTERNAL_ERROR, message, args); + } + + @Override + public void internalError(String message, Throwable t) { + error(INTERNAL_ERROR, message, t); + } + + @Override + public void error(String code, String message, Object... args) { + if (args == null || args.length == 0) { + delegate.error(code, cause, extendedInformation, message); + return; + } + formatAndError(code, message, args); + } + + @Override + public void error(String code, String message, Throwable t) { + delegate.error(code, cause, extendedInformation, message, t); + } + + @Override + public void log(Level level) { + switch (level) { + case TRACE: + trace(); + break; + case DEBUG: + debug(); + break; + case INFO: + info(); + break; + case WARN: + internalWarn(); + break; + case ERROR: + internalError(); + break; + default: + } + } + + @Override + public void log(Level level, Throwable t) { + switch (level) { + case TRACE: + trace(t); + break; + case DEBUG: + debug(t); + break; + case INFO: + info(t); + break; + case WARN: + internalWarn(t); + break; + case ERROR: + internalError(t); + break; + default: + } + } + + @Override + public void log(Level level, String msg) { + switch (level) { + case TRACE: + trace(msg); + break; + case DEBUG: + debug(msg); + break; + case INFO: + info(msg); + break; + case WARN: + internalWarn(msg); + break; + case ERROR: + internalError(msg); + break; + default: + } + } + + @Override + public void log(Level level, String msg, Object... args) { + switch (level) { + case TRACE: + trace(msg, args); + break; + case DEBUG: + debug(msg, args); + break; + case INFO: + info(msg, args); + break; + case WARN: + internalWarn(msg, args); + break; + case ERROR: + internalError(msg, args); + break; + default: + } + } + + @Override + public void log(Level level, String msg, Throwable t) { + switch (level) { + case TRACE: + trace(msg, t); + break; + case DEBUG: + debug(msg, t); + break; + case INFO: + info(msg, t); + break; + case WARN: + internalWarn(msg, t); + break; + case ERROR: + internalError(msg, t); + break; + default: + } + } + + @Override + public void log(Level level, String code, String msg, Object... args) { + switch (level) { + case TRACE: + trace(code, msg, args); + break; + case DEBUG: + debug(code, msg, args); + break; + case INFO: + info(code, msg, args); + break; + case WARN: + warn(code, msg, args); + break; + case ERROR: + error(code, msg, args); + break; + default: + } + } + + @Override + public void log(Level level, String code, String msg, Throwable t) { + switch (level) { + case TRACE: + trace(code, msg, t); + break; + case DEBUG: + debug(code, msg, t); + break; + case INFO: + info(code, msg, t); + break; + case WARN: + warn(code, msg, t); + break; + case ERROR: + error(code, msg, t); + break; + default: + } + } + + @Override + public boolean isTraceEnabled() { + return delegate.isTraceEnabled(); + } + + @Override + public boolean isDebugEnabled() { + return delegate.isDebugEnabled(); + } + + @Override + public boolean isInfoEnabled() { + return delegate.isInfoEnabled(); + } + + @Override + public boolean isWarnEnabled() { + return delegate.isWarnEnabled(); + } + + @Override + public boolean isErrorEnabled() { + return delegate.isErrorEnabled(); + } + + private FluentLoggerImpl getLogger() { + return this == root ? new FluentLoggerImpl(this) : this; + } + + private void warnMessageMissing() { + delegate.warn(INTERNAL_ERROR, cause, extendedInformation, "Message must not be empty"); + } + + private static Object[] formatArgs(Object[] args) { + for (int i = 0; i < args.length; i++) { + if (args[i] instanceof Supplier) { + args[i] = ((Supplier) args[i]).get(); + } + } + return args; + } +} diff --git a/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/h12/AbstractServerTransportListener.java b/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/h12/AbstractServerTransportListener.java index ac4f59e61a74..16e52d990feb 100644 --- a/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/h12/AbstractServerTransportListener.java +++ b/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/h12/AbstractServerTransportListener.java @@ -18,8 +18,8 @@ import org.apache.dubbo.common.URL; import org.apache.dubbo.common.constants.CommonConstants; -import org.apache.dubbo.common.logger.ErrorTypeAwareLogger; -import org.apache.dubbo.common.logger.LoggerFactory; +import org.apache.dubbo.common.constants.LoggerCodeConstants; +import org.apache.dubbo.common.logger.FluentLogger; import org.apache.dubbo.common.utils.MethodUtils; import org.apache.dubbo.remoting.http12.ExceptionHandler; import org.apache.dubbo.remoting.http12.HttpChannel; @@ -37,6 +37,7 @@ import org.apache.dubbo.rpc.protocol.tri.DescriptorUtils; import org.apache.dubbo.rpc.protocol.tri.ExceptionUtils; import org.apache.dubbo.rpc.protocol.tri.RpcInvocationBuildContext; +import org.apache.dubbo.rpc.protocol.tri.TripleConstant; import org.apache.dubbo.rpc.protocol.tri.TripleHeaderEnum; import org.apache.dubbo.rpc.protocol.tri.TripleProtocol; import org.apache.dubbo.rpc.protocol.tri.h12.http2.CompositeExceptionHandler; @@ -49,16 +50,10 @@ import java.util.concurrent.Executor; import java.util.function.Supplier; -import static org.apache.dubbo.common.constants.LoggerCodeConstants.COMMON_ERROR_USE_THREAD_POOL; -import static org.apache.dubbo.common.constants.LoggerCodeConstants.INTERNAL_ERROR; -import static org.apache.dubbo.common.constants.LoggerCodeConstants.PROTOCOL_FAILED_PARSE; -import static org.apache.dubbo.rpc.protocol.tri.TripleConstant.REMOTE_ADDRESS_KEY; - public abstract class AbstractServerTransportListener
implements HttpTransportListener { - private static final ErrorTypeAwareLogger LOGGER = - LoggerFactory.getErrorTypeAwareLogger(AbstractServerTransportListener.class); + private static final FluentLogger LOGGER = FluentLogger.of(AbstractServerTransportListener.class); private final FrameworkModel frameworkModel; private final URL url; @@ -88,12 +83,12 @@ public void onMetadata(HEADER metadata) { try { executor = initializeExecutor(metadata); } catch (Throwable throwable) { - LOGGER.error(COMMON_ERROR_USE_THREAD_POOL, "", "", "initialize executor fail.", throwable); + LOGGER.error(LoggerCodeConstants.COMMON_ERROR_USE_THREAD_POOL, "Initialize executor fail.", throwable); onError(throwable); return; } if (executor == null) { - LOGGER.error(INTERNAL_ERROR, "", "", "executor must be not null."); + LOGGER.error(LoggerCodeConstants.INTERNAL_ERROR, "Executor must be not null."); onError(new NullPointerException("initializeExecutor return null")); return; } @@ -198,34 +193,7 @@ protected void logError(Throwable t) { } return sb.toString(); }; - switch (exceptionHandler.resolveLogLevel(t)) { - case TRACE: - if (LOGGER.isTraceEnabled()) { - LOGGER.trace(msg.get(), t); - } - return; - case DEBUG: - if (LOGGER.isDebugEnabled()) { - LOGGER.debug(msg.get(), t); - } - return; - case INFO: - if (LOGGER.isInfoEnabled()) { - LOGGER.info(msg.get(), t); - } - return; - case WARN: - if (LOGGER.isWarnEnabled()) { - LOGGER.warn(INTERNAL_ERROR, "", "", msg.get(), t); - } - return; - case ERROR: - if (LOGGER.isErrorEnabled()) { - LOGGER.error(INTERNAL_ERROR, "", "", msg.get(), t); - } - return; - default: - } + LOGGER.msg(msg).log(exceptionHandler.resolveLogLevel(t), t); } protected void onError(Throwable throwable) { @@ -282,7 +250,7 @@ protected RpcInvocation buildRpcInvocation(RpcInvocationBuildContext context) { inv.setTargetServiceUniqueName(url.getServiceKey()); inv.setReturnTypes(methodDescriptor.getReturnTypes()); inv.setObjectAttachments(StreamUtils.toAttachments(httpMetadata.headers())); - inv.put(REMOTE_ADDRESS_KEY, httpChannel.remoteAddress()); + inv.put(TripleConstant.REMOTE_ADDRESS_KEY, httpChannel.remoteAddress()); inv.getAttributes().putAll(context.getAttributes()); String consumerAppName = httpMetadata.headers().getFirst(TripleHeaderEnum.CONSUMER_APP_NAME_KEY.getHeader()); if (null != consumerAppName) { @@ -310,12 +278,11 @@ protected RpcInvocation onBuildRpcInvocationCompletion(RpcInvocation invocation) } } catch (Throwable t) { LOGGER.warn( - PROTOCOL_FAILED_PARSE, - "", - "", - String.format( - "Failed to parse request timeout set from:%s, service=%s " + "method=%s", - timeoutString, context.getServiceDescriptor().getInterfaceName(), context.getMethodName())); + LoggerCodeConstants.PROTOCOL_FAILED_PARSE, + "Failed to parse request timeout set from: {}, service={}, method={}", + timeoutString, + context.getServiceDescriptor().getInterfaceName(), + context.getMethodName()); } return invocation; } diff --git a/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/filter/DefaultFilterChain.java b/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/filter/DefaultFilterChain.java index f4ddd2ad26c5..30cf418442ea 100644 --- a/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/filter/DefaultFilterChain.java +++ b/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/filter/DefaultFilterChain.java @@ -16,9 +16,7 @@ */ package org.apache.dubbo.rpc.protocol.tri.rest.filter; -import org.apache.dubbo.common.constants.LoggerCodeConstants; -import org.apache.dubbo.common.logger.ErrorTypeAwareLogger; -import org.apache.dubbo.common.logger.LoggerFactory; +import org.apache.dubbo.common.logger.FluentLogger; import org.apache.dubbo.remoting.http12.HttpRequest; import org.apache.dubbo.remoting.http12.HttpResponse; import org.apache.dubbo.rpc.AppResponse; @@ -33,7 +31,7 @@ final class DefaultFilterChain implements FilterChain, Listener { - private static final ErrorTypeAwareLogger LOGGER = LoggerFactory.getErrorTypeAwareLogger(DefaultFilterChain.class); + private static final FluentLogger LOGGER = FluentLogger.of(DefaultFilterChain.class); private final RestFilter[] filters; private final Invocation invocation; @@ -106,11 +104,7 @@ public void onResponse(Result result, HttpRequest request, HttpResponse response try { ((Listener) filter).onResponse(result, request, response); } catch (Throwable t) { - LOGGER.error( - LoggerCodeConstants.COMMON_UNEXPECTED_EXCEPTION, - "", - "", - "Call onResponse for filter " + "[" + filter + "] error"); + LOGGER.internalError("Call onResponse for filter [{}] error", filter); } } } @@ -124,11 +118,7 @@ public void onError(Throwable t, HttpRequest request, HttpResponse response) { try { ((Listener) filter).onError(t, request, response); } catch (Throwable th) { - LOGGER.error( - LoggerCodeConstants.COMMON_UNEXPECTED_EXCEPTION, - "", - "", - "Call onError for filter " + "[" + filter + "] error"); + LOGGER.internalError("Call onError for filter [{}] error", filter); } } } diff --git a/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/mapping/DefaultRequestMappingRegistry.java b/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/mapping/DefaultRequestMappingRegistry.java index 4efc6920121d..80f7587a49fa 100644 --- a/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/mapping/DefaultRequestMappingRegistry.java +++ b/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/mapping/DefaultRequestMappingRegistry.java @@ -19,8 +19,7 @@ import org.apache.dubbo.common.URL; import org.apache.dubbo.common.config.Configuration; import org.apache.dubbo.common.config.ConfigurationUtils; -import org.apache.dubbo.common.constants.LoggerCodeConstants; -import org.apache.dubbo.common.logger.ErrorTypeAwareLogger; +import org.apache.dubbo.common.logger.FluentLogger; import org.apache.dubbo.config.nested.RestConfig; import org.apache.dubbo.remoting.http12.HttpRequest; import org.apache.dubbo.remoting.http12.message.MethodMetadata; @@ -52,12 +51,9 @@ import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; -import static org.apache.dubbo.common.logger.LoggerFactory.getErrorTypeAwareLogger; -import static org.apache.dubbo.rpc.protocol.tri.rest.Messages.AMBIGUOUS_MAPPING; - public final class DefaultRequestMappingRegistry implements RequestMappingRegistry { - private static final ErrorTypeAwareLogger LOGGER = getErrorTypeAwareLogger(DefaultRequestMappingRegistry.class); + private static final FluentLogger LOGGER = FluentLogger.of(DefaultRequestMappingRegistry.class); private final FrameworkModel frameworkModel; private final ContentNegotiator contentNegotiator; @@ -161,8 +157,7 @@ private void register0(RequestMapping mapping, HandlerMeta handler) { LOGGER.debug(msg, path, mapping, handler.getMethod()); } } else if (LOGGER.isWarnEnabled()) { - String msg = Messages.DUPLICATE_MAPPING.format(path, mapping, handler.getMethod(), exists); - LOGGER.warn(LoggerCodeConstants.INTERNAL_ERROR, "", "", msg); + LOGGER.internalWarn(Messages.DUPLICATE_MAPPING.format(path, mapping, handler.getMethod(), exists)); } } } finally { @@ -259,7 +254,7 @@ public HandlerMeta lookup(HttpRequest request) { Candidate first = candidates.get(0); Candidate second = candidates.get(1); if (first.mapping.compareTo(second.mapping, request) == 0) { - throw new RestMappingException(AMBIGUOUS_MAPPING, path, first, second); + throw new RestMappingException(Messages.AMBIGUOUS_MAPPING, path, first, second); } }