openecomp-be/lib/openecomp-sdc-logging-lib/openecomp-sdc-logging-core/src/main/java/org/openecomp/sdc/logging/slf4j/SLF4JLoggerWrapper.java

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