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 java.text.SimpleDateFormat;
  20 import java.util.UUID;
  21 import org.openecomp.sdc.logging.api.AuditData;
  22 import org.openecomp.sdc.logging.api.Logger;
  23 import org.openecomp.sdc.logging.api.MetricsData;
  24 import org.slf4j.LoggerFactory;
  25 import org.slf4j.MDC;
  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.EXIT);
 119     }
 120
 121     @Override
 122     public void auditEntry(AuditData data) {
 123
 124         if (data == null) {
 125             return; // not failing if null
 126         }
 127
 128         try {
 129             putAuditOnMdc(data);
 130             logger.info(Markers.ENTRY, "");
 131         } finally {
 132             clearAuditFromMdc();
 133         }
 134     }
 135
 136
 137     @Override
 138     public void auditExit(AuditData data) {
 139
 140         if (data == null) {
 141             return; // not failing if null
 142         }
 143
 144         try {
 145             putAuditOnMdc(data);
 146             logger.info(Markers.EXIT, "");
 147         } finally {
 148             clearAuditFromMdc();
 149         }
 150     }
 151
 152     private void putAuditOnMdc(AuditData audit) {
 153
 154         SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_TIME_PATTERN);
 155         unsafePutOnMdc(AuditField.BEGIN_TIMESTAMP, dateFormat.format(audit.getStartTime()));
 156         unsafePutOnMdc(AuditField.END_TIMESTAMP, dateFormat.format(audit.getEndTime()));
 157         unsafePutOnMdc(AuditField.ELAPSED_TIME, String.valueOf(audit.getEndTime() - audit.getStartTime()));
 158         safePutOnMdc(AuditField.RESPONSE_CODE, audit.getResponseCode());
 159         safePutOnMdc(AuditField.RESPONSE_DESCRIPTION, audit.getResponseDescription());
 160         safePutOnMdc(AuditField.CLIENT_IP_ADDRESS, audit.getClientIpAddress());
 161         unsafePutOnMdc(AuditField.INVOCATION_ID, UUID.randomUUID().toString());
 162
 163         if (audit.getStatusCode() != null) {
 164             unsafePutOnMdc(AuditField.STATUS_CODE, audit.getStatusCode().name());
 165         }
 166     }
 167
 168     private void clearAuditFromMdc() {
 169         for (AuditField f : AuditField.values()) {
 170             MDC.remove(f.asKey());
 171         }
 172     }
 173
 174     @Override
 175     public boolean isDebugEnabled() {
 176         return logger.isDebugEnabled();
 177     }
 178
 179     @Override
 180     public void debug(String msg) {
 181         logger.debug(msg);
 182     }
 183
 184     @Override
 185     public void debug(String format, Object arg) {
 186         logger.debug(format, arg);
 187     }
 188
 189     @Override
 190     public void debug(String format, Object arg1, Object arg2) {
 191         logger.debug(format, arg1, arg2);
 192     }
 193
 194     @Override
 195     public void debug(String format, Object... arguments) {
 196         logger.debug(format, arguments);
 197     }
 198
 199     @Override
 200     public void debug(String msg, Throwable t) {
 201         logger.debug(msg, t);
 202     }
 203
 204     @Override
 205     public boolean isInfoEnabled() {
 206         return logger.isInfoEnabled();
 207     }
 208
 209     @Override
 210     public void info(String msg) {
 211         logger.info(msg);
 212     }
 213
 214     @Override
 215     public void info(String format, Object arg) {
 216         logger.info(format, arg);
 217     }
 218
 219     @Override
 220     public void info(String format, Object arg1, Object arg2) {
 221         logger.info(format, arg1, arg2);
 222     }
 223
 224     @Override
 225     public void info(String format, Object... arguments) {
 226         logger.info(format, arguments);
 227     }
 228
 229     @Override
 230     public void info(String msg, Throwable t) {
 231         logger.info(msg, t);
 232     }
 233
 234     @Override
 235     public boolean isWarnEnabled() {
 236         return logger.isWarnEnabled();
 237     }
 238
 239     @Override
 240     public void warn(String msg) {
 241         logger.warn(msg);
 242     }
 243
 244     @Override
 245     public void warn(String format, Object arg) {
 246         logger.warn(format, arg);
 247     }
 248
 249     @Override
 250     public void warn(String format, Object... arguments) {
 251         logger.warn(format, arguments);
 252     }
 253
 254     @Override
 255     public void warn(String format, Object arg1, Object arg2) {
 256         logger.warn(format, arg1, arg2);
 257     }
 258
 259     @Override
 260     public void warn(String msg, Throwable t) {
 261         logger.warn(msg, t);
 262     }
 263
 264     @Override
 265     public boolean isErrorEnabled() {
 266         return logger.isErrorEnabled();
 267     }
 268
 269     @Override
 270     public void error(String msg) {
 271         logger.error(msg);
 272     }
 273
 274     @Override
 275     public void error(String format, Object arg) {
 276         logger.error(format, arg);
 277     }
 278
 279     @Override
 280     public void error(String format, Object arg1, Object arg2) {
 281         logger.error(format, arg1, arg2);
 282     }
 283
 284     @Override
 285     public void error(String format, Object... arguments) {
 286         logger.error(format, arguments);
 287     }
 288
 289     @Override
 290     public void error(String msg, Throwable t) {
 291         logger.error(msg, t);
 292     }
 293 }