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