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 static org.openecomp.sdc.logging.slf4j.SLF4JLoggerWrapper.AuditField.BEGIN_TIMESTAMP;
  20 import static org.openecomp.sdc.logging.slf4j.SLF4JLoggerWrapper.AuditField.CLIENT_IP_ADDRESS;
  21 import static org.openecomp.sdc.logging.slf4j.SLF4JLoggerWrapper.AuditField.ELAPSED_TIME;
  22 import static org.openecomp.sdc.logging.slf4j.SLF4JLoggerWrapper.AuditField.END_TIMESTAMP;
  23 import static org.openecomp.sdc.logging.slf4j.SLF4JLoggerWrapper.AuditField.RESPONSE_CODE;
  24 import static org.openecomp.sdc.logging.slf4j.SLF4JLoggerWrapper.AuditField.RESPONSE_DESCRIPTION;
  25 import static org.openecomp.sdc.logging.slf4j.SLF4JLoggerWrapper.AuditField.STATUS_CODE;
  26
  27 import java.text.Format;
  28 import java.text.SimpleDateFormat;
  29 import org.openecomp.sdc.logging.api.AuditData;
  30 import org.openecomp.sdc.logging.api.Logger;
  31 import org.slf4j.LoggerFactory;
  32 import org.slf4j.MDC;
  33
  34 /**
  35  * @author evitaliy
  36  * @since 08 Jan 18
  37  */
  38 class SLF4JLoggerWrapper implements Logger {
  39
  40     //The specified format presents time in UTC formatted per ISO 8601, as required by ONAP logging guidelines
  41     private static final String DATE_TIME_PATTERN = "yyyy-MM-dd'T'HH:mm:ss.SSSXXX";
  42
  43     private static final String PREFIX = "";
  44
  45     enum AuditField {
  46
  47         BEGIN_TIMESTAMP(PREFIX + "BeginTimestamp"),
  48         END_TIMESTAMP(PREFIX + "EndTimestamp"),
  49         ELAPSED_TIME(PREFIX + "ElapsedTime"),
  50         STATUS_CODE(PREFIX + "StatusCode"),
  51         RESPONSE_CODE(PREFIX + "ResponseCode"),
  52         RESPONSE_DESCRIPTION(PREFIX + "ResponseDescription"),
  53         CLIENT_IP_ADDRESS(PREFIX + "ClientIpAddress");
  54
  55         private final String key;
  56
  57         AuditField(String key) {
  58             this.key = key;
  59         }
  60
  61         public String asKey() {
  62             return key;
  63         }
  64     }
  65
  66     private final org.slf4j.Logger logger;
  67
  68     SLF4JLoggerWrapper(org.slf4j.Logger delegate) {
  69         this.logger = delegate;
  70     }
  71
  72     // May cause http://www.slf4j.org/codes.html#loggerNameMismatch
  73     SLF4JLoggerWrapper(Class<?> clazz) {
  74         this(LoggerFactory.getLogger(clazz));
  75     }
  76
  77     SLF4JLoggerWrapper(String className) {
  78         this(LoggerFactory.getLogger(className));
  79     }
  80
  81     @Override
  82     public String getName() {
  83         return logger.getName();
  84     }
  85
  86     @Override
  87     public boolean isMetricsEnabled() {
  88         return logger.isInfoEnabled(Markers.METRICS);
  89     }
  90
  91     @Override
  92     public void metrics(String msg) {
  93         logger.info(Markers.METRICS, msg);
  94     }
  95
  96     @Override
  97     public void metrics(String msg, Object arg) {
  98         logger.info(Markers.METRICS, msg, arg);
  99     }
 100
 101     @Override
 102     public void metrics(String msg, Object arg1, Object arg2) {
 103         logger.info(Markers.METRICS, msg, arg1, arg2);
 104     }
 105
 106     @Override
 107     public void metrics(String msg, Object... arguments) {
 108         logger.info(Markers.METRICS, msg, arguments);
 109     }
 110
 111     @Override
 112     public void metrics(String msg, Throwable t) {
 113         logger.info(Markers.METRICS, msg, t);
 114     }
 115
 116     @Override
 117     public boolean isAuditEnabled() {
 118         return logger.isInfoEnabled(Markers.AUDIT);
 119     }
 120
 121     @Override
 122     public void audit(AuditData data) {
 123
 124         if (data == null) {
 125             return; // not failing if null
 126         }
 127
 128         putTimes(data);
 129         putIfNotNull(RESPONSE_CODE.key, data.getResponseCode());
 130         putIfNotNull(RESPONSE_DESCRIPTION.key, data.getResponseDescription());
 131         putIfNotNull(CLIENT_IP_ADDRESS.key, data.getClientIpAddress());
 132
 133         if (data.getStatusCode() != null) {
 134             MDC.put(STATUS_CODE.key, data.getStatusCode().name());
 135         }
 136
 137         try {
 138             logger.info(Markers.AUDIT, "");
 139         } finally {
 140             for (AuditField f : AuditField.values()) {
 141                 MDC.remove(f.key);
 142             }
 143         }
 144     }
 145
 146     private void putIfNotNull(String key, String value) {
 147         if (value != null) {
 148             MDC.put(key, value);
 149         }
 150     }
 151
 152     private void putTimes(AuditData data) {
 153         // SimpleDateFormat is not thread-safe and cannot be a constant
 154         Format dateTimeFormat = new SimpleDateFormat(DATE_TIME_PATTERN);
 155         MDC.put(BEGIN_TIMESTAMP.key, dateTimeFormat.format(data.getStartTime()));
 156         MDC.put(END_TIMESTAMP.key, dateTimeFormat.format(data.getEndTime()));
 157         MDC.put(ELAPSED_TIME.key, String.valueOf(data.getEndTime() - data.getStartTime()));
 158     }
 159
 160     @Override
 161     public boolean isDebugEnabled() {
 162         return logger.isDebugEnabled();
 163     }
 164
 165     @Override
 166     public void debug(String msg) {
 167         logger.debug(msg);
 168     }
 169
 170     @Override
 171     public void debug(String format, Object arg) {
 172         logger.debug(format, arg);
 173     }
 174
 175     @Override
 176     public void debug(String format, Object arg1, Object arg2) {
 177         logger.debug(format, arg1, arg2);
 178     }
 179
 180     @Override
 181     public void debug(String format, Object... arguments) {
 182         logger.debug(format, arguments);
 183     }
 184
 185     @Override
 186     public void debug(String msg, Throwable t) {
 187         logger.debug(msg, t);
 188     }
 189
 190     @Override
 191     public boolean isInfoEnabled() {
 192         return logger.isInfoEnabled();
 193     }
 194
 195     @Override
 196     public void info(String msg) {
 197         logger.info(msg);
 198     }
 199
 200     @Override
 201     public void info(String format, Object arg) {
 202         logger.info(format, arg);
 203     }
 204
 205     @Override
 206     public void info(String format, Object arg1, Object arg2) {
 207         logger.info(format, arg1, arg2);
 208     }
 209
 210     @Override
 211     public void info(String format, Object... arguments) {
 212         logger.info(format, arguments);
 213     }
 214
 215     @Override
 216     public void info(String msg, Throwable t) {
 217         logger.info(msg, t);
 218     }
 219
 220     @Override
 221     public boolean isWarnEnabled() {
 222         return logger.isWarnEnabled();
 223     }
 224
 225     @Override
 226     public void warn(String msg) {
 227         logger.warn(msg);
 228     }
 229
 230     @Override
 231     public void warn(String format, Object arg) {
 232         logger.warn(format, arg);
 233     }
 234
 235     @Override
 236     public void warn(String format, Object... arguments) {
 237         logger.warn(format, arguments);
 238     }
 239
 240     @Override
 241     public void warn(String format, Object arg1, Object arg2) {
 242         logger.warn(format, arg1, arg2);
 243     }
 244
 245     @Override
 246     public void warn(String msg, Throwable t) {
 247         logger.warn(msg, t);
 248     }
 249
 250     @Override
 251     public boolean isErrorEnabled() {
 252         return logger.isErrorEnabled();
 253     }
 254
 255     @Override
 256     public void error(String msg) {
 257         logger.error(msg);
 258     }
 259
 260     @Override
 261     public void error(String format, Object arg) {
 262         logger.error(format, arg);
 263     }
 264
 265     @Override
 266     public void error(String format, Object arg1, Object arg2) {
 267         logger.error(format, arg1, arg2);
 268     }
 269
 270     @Override
 271     public void error(String format, Object... arguments) {
 272         logger.error(format, arguments);
 273     }
 274
 275     @Override
 276     public void error(String msg, Throwable t) {
 277         logger.error(msg, t);
 278     }
 279 }