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