gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.logging.slf4j;
  18
  19 import java.text.Format;
  20 import java.text.SimpleDateFormat;
  21 import org.openecomp.sdc.logging.api.AuditData;
  22 import org.openecomp.sdc.logging.api.Logger;
  23 import org.slf4j.LoggerFactory;
  24 import org.slf4j.MDC;
  25
  26 /**
  27  * @author EVITALIY
  28  * @since 08 Jan 18
  29  */
  30 class SLF4JLoggerWrapper implements Logger {
  31
  32     //The specified format presents time in UTC formatted per ISO 8601, as required by ONAP logging guidelines
  33
  34     private static final String DATE_TIME_PATTERN = "yyyy-MM-dd'T'HH:mm:ss.SSSXXX";
  35     private static final String PREFIX = "";
  36
  37     static final String BEGIN_TIMESTAMP = PREFIX + "BeginTimestamp";
  38     static final String END_TIMESTAMP = PREFIX + "EndTimestamp";
  39     static final String ELAPSED_TIME = PREFIX + "ElapsedTime";
  40     static final String STATUS_CODE = PREFIX + "StatusCode";
  41     static final String RESPONSE_CODE = PREFIX + "ResponseCode";
  42     static final String RESPONSE_DESCRIPTION = PREFIX + "ResponseDescription";
  43     static final String CLIENT_IP_ADDRESS = PREFIX + "ClientIpAddress";
  44
  45     private static final String[] ALL_MDC_FIELDS = {
  46         BEGIN_TIMESTAMP, END_TIMESTAMP, ELAPSED_TIME, STATUS_CODE,
  47         RESPONSE_CODE, RESPONSE_DESCRIPTION, CLIENT_IP_ADDRESS
  48     };
  49
  50     private final org.slf4j.Logger logger;
  51
  52     SLF4JLoggerWrapper(org.slf4j.Logger delegate) {
  53         this.logger = delegate;
  54     }
  55
  56     // May cause http://www.slf4j.org/codes.html#loggerNameMismatch
  57     SLF4JLoggerWrapper(Class<?> clazz) {
  58         this(LoggerFactory.getLogger(clazz));
  59     }
  60
  61     SLF4JLoggerWrapper(String className) {
  62         this(LoggerFactory.getLogger(className));
  63     }
  64
  65     @Override
  66     public String getName() {
  67         return logger.getName();
  68     }
  69
  70     @Override
  71     public boolean isMetricsEnabled() {
  72         return logger.isInfoEnabled(Markers.METRICS);
  73     }
  74
  75     @Override
  76     public void metrics(String msg) {
  77         logger.info(Markers.METRICS, msg);
  78     }
  79
  80     @Override
  81     public void metrics(String msg, Object arg) {
  82         logger.info(Markers.METRICS, msg, arg);
  83     }
  84
  85     @Override
  86     public void metrics(String msg, Object arg1, Object arg2) {
  87         logger.info(Markers.METRICS, msg, arg1, arg2);
  88     }
  89
  90     @Override
  91     public void metrics(String msg, Object... arguments) {
  92         logger.info(Markers.METRICS, msg, arguments);
  93     }
  94
  95     @Override
  96     public void metrics(String msg, Throwable t) {
  97         logger.info(Markers.METRICS, msg, t);
  98     }
  99
 100     @Override
 101     public boolean isAuditEnabled() {
 102         return logger.isInfoEnabled(Markers.AUDIT);
 103     }
 104
 105     @Override
 106     public void audit(AuditData data) {
 107
 108         if (data == null) {
 109             return; // not failing if null
 110         }
 111
 112         putTimes(data);
 113         putIfNotNull(RESPONSE_CODE, data.getResponseCode());
 114         putIfNotNull(RESPONSE_DESCRIPTION, data.getResponseDescription());
 115         putIfNotNull(CLIENT_IP_ADDRESS, data.getClientIpAddress());
 116
 117         if (data.getStatusCode() != null) {
 118             MDC.put(STATUS_CODE, data.getStatusCode().name());
 119         }
 120
 121         try {
 122             logger.info(Markers.AUDIT, "");
 123         } finally {
 124             for (String k : ALL_MDC_FIELDS) {
 125                 MDC.remove(k);
 126             }
 127         }
 128     }
 129
 130     private void putIfNotNull(String key, String value) {
 131         if (value != null) {
 132             MDC.put(key, value);
 133         }
 134     }
 135
 136     private void putTimes(AuditData data) {
 137         // SimpleDateFormat is not thread-safe and cannot be a constant
 138         Format dateTimeFormat = new SimpleDateFormat(DATE_TIME_PATTERN);
 139         MDC.put(BEGIN_TIMESTAMP, dateTimeFormat.format(data.getStartTime()));
 140         MDC.put(END_TIMESTAMP, dateTimeFormat.format(data.getEndTime()));
 141         MDC.put(ELAPSED_TIME, String.valueOf(data.getEndTime() - data.getStartTime()));
 142     }
 143
 144     @Override
 145     public boolean isDebugEnabled() {
 146         return logger.isDebugEnabled();
 147     }
 148
 149     @Override
 150     public void debug(String msg) {
 151         logger.debug(msg);
 152     }
 153
 154     @Override
 155     public void debug(String format, Object arg) {
 156         logger.debug(format, arg);
 157     }
 158
 159     @Override
 160     public void debug(String format, Object arg1, Object arg2) {
 161         logger.debug(format, arg1, arg2);
 162     }
 163
 164     @Override
 165     public void debug(String format, Object... arguments) {
 166         logger.debug(format, arguments);
 167     }
 168
 169     @Override
 170     public void debug(String msg, Throwable t) {
 171         logger.debug(msg, t);
 172     }
 173
 174     @Override
 175     public boolean isInfoEnabled() {
 176         return logger.isInfoEnabled();
 177     }
 178
 179     @Override
 180     public void info(String msg) {
 181         logger.info(msg);
 182     }
 183
 184     @Override
 185     public void info(String format, Object arg) {
 186         logger.info(format, arg);
 187     }
 188
 189     @Override
 190     public void info(String format, Object arg1, Object arg2) {
 191         logger.info(format, arg1, arg2);
 192     }
 193
 194     @Override
 195     public void info(String format, Object... arguments) {
 196         logger.info(format, arguments);
 197     }
 198
 199     @Override
 200     public void info(String msg, Throwable t) {
 201         logger.info(msg, t);
 202     }
 203
 204     @Override
 205     public boolean isWarnEnabled() {
 206         return logger.isWarnEnabled();
 207     }
 208
 209     @Override
 210     public void warn(String msg) {
 211         logger.warn(msg);
 212     }
 213
 214     @Override
 215     public void warn(String format, Object arg) {
 216         logger.warn(format, arg);
 217     }
 218
 219     @Override
 220     public void warn(String format, Object... arguments) {
 221         logger.warn(format, arguments);
 222     }
 223
 224     @Override
 225     public void warn(String format, Object arg1, Object arg2) {
 226         logger.warn(format, arg1, arg2);
 227     }
 228
 229     @Override
 230     public void warn(String msg, Throwable t) {
 231         logger.warn(msg, t);
 232     }
 233
 234     @Override
 235     public boolean isErrorEnabled() {
 236         return logger.isErrorEnabled();
 237     }
 238
 239     @Override
 240     public void error(String msg) {
 241         logger.error(msg);
 242     }
 243
 244     @Override
 245     public void error(String format, Object arg) {
 246         logger.error(format, arg);
 247     }
 248
 249     @Override
 250     public void error(String format, Object arg1, Object arg2) {
 251         logger.error(format, arg1, arg2);
 252     }
 253
 254     @Override
 255     public void error(String format, Object... arguments) {
 256         logger.error(format, arguments);
 257     }
 258
 259     @Override
 260     public void error(String msg, Throwable t) {
 261         logger.error(msg, t);
 262     }
 263 }