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.api;
  18
  19 import java.util.Objects;
  20 import org.openecomp.sdc.logging.spi.LoggerCreationService;
  21
  22 /**
  23  * <a>Factory to hide a concrete, framework-specific implementation of logger creation.</a>
  24  * <p>The service used by this factory must implement {@link LoggerCreationService}. If no
  25  * implementation has been configured or could be instantiated, a <b>no-op logger</b> will be
  26  * used, and <b>no events</b> will be logged. This is done to prevent recursion if attempts are
  27  * being made to log exceptions that resulted from logger initialization. </p>
  28  *
  29  * @author evitaliy
  30  * @since 13/09/2016.
  31  *
  32  * @see ServiceBinder
  33  * @see LoggerCreationService
  34  */
  35 public class LoggerFactory {
  36
  37     // use the no-op service to prevent recursion in case of an attempt to log an exception as a
  38     // result of a logger initialization error
  39     private static final LoggerCreationService SERVICE = ServiceBinder.getCreationServiceBinding().orElseGet(
  40             NoOpLoggerCreationService::new);
  41
  42     private LoggerFactory() {
  43         // prevent instantiation
  44     }
  45
  46     public static Logger getLogger(String clazzName) {
  47         return SERVICE.getLogger(clazzName);
  48     }
  49
  50     public static Logger getLogger(Class<?> clazz) {
  51         return SERVICE.getLogger(clazz);
  52     }
  53
  54     private static class NoOpLoggerCreationService implements LoggerCreationService {
  55
  56         private static class NoOpLogger implements Logger {
  57
  58             private static final Logger INSTANCE = new NoOpLogger();
  59
  60             @Override
  61             public String getName() {
  62                 return "No-Op Logger";
  63             }
  64
  65             @Override
  66             public boolean isMetricsEnabled() {
  67                 return false;
  68             }
  69
  70             @Override
  71             public void metrics(MetricsData msg) {
  72                 // no-op
  73             }
  74
  75             @Override
  76             public void metrics(String msg) {
  77                 // no-op
  78             }
  79
  80             @Override
  81             public boolean isAuditEnabled() {
  82                 return false;
  83             }
  84
  85             @Override
  86             public void auditEntry(AuditData data) {
  87                 // no-op
  88             }
  89
  90             @Override
  91             public void auditExit(AuditData data) {
  92                 // no-op
  93             }
  94
  95             @Override
  96             public boolean isDebugEnabled() {
  97                 return false;
  98             }
  99
 100             @Override
 101             public void debug(String msg) {
 102                 // no-op
 103             }
 104
 105             @Override
 106             public void debug(String msg, Object arg) {
 107                 // no-op
 108             }
 109
 110             @Override
 111             public void debug(String msg, Object arg1, Object arg2) {
 112                 // no-op
 113             }
 114
 115             @Override
 116             public void debug(String msg, Object... arguments) {
 117                 // no-op
 118             }
 119
 120             @Override
 121             public void debug(String msg, Throwable t) {
 122                 // no-op
 123             }
 124
 125             @Override
 126             public boolean isInfoEnabled() {
 127                 return false;
 128             }
 129
 130             @Override
 131             public void info(String msg) {
 132                 // no-op
 133             }
 134
 135             @Override
 136             public void info(String msg, Object arg) {
 137                 // no-op
 138             }
 139
 140             @Override
 141             public void info(String msg, Object arg1, Object arg2) {
 142                 // no-op
 143             }
 144
 145             @Override
 146             public void info(String msg, Object... arguments) {
 147                 // no-op
 148             }
 149
 150             @Override
 151             public void info(String msg, Throwable t) {
 152                 // no-op
 153             }
 154
 155             @Override
 156             public boolean isWarnEnabled() {
 157                 return false;
 158             }
 159
 160             @Override
 161             public void warn(String msg) {
 162                 // no-op
 163             }
 164
 165             @Override
 166             public void warn(String msg, Object arg) {
 167                 // no-op
 168             }
 169
 170             @Override
 171             public void warn(String msg, Object... arguments) {
 172                 // no-op
 173             }
 174
 175             @Override
 176             public void warn(String msg, Object arg1, Object arg2) {
 177                 // no-op
 178             }
 179
 180             @Override
 181             public void warn(String msg, Throwable t) {
 182                 // no-op
 183             }
 184
 185             @Override
 186             public boolean isErrorEnabled() {
 187                 return false;
 188             }
 189
 190             @Override
 191             public void error(String msg) {
 192                 // no-op
 193             }
 194
 195             @Override
 196             public void error(String msg, Object arg) {
 197                 // no-op
 198             }
 199
 200             @Override
 201             public void error(String msg, Object arg1, Object arg2) {
 202                 // no-op
 203             }
 204
 205             @Override
 206             public void error(String msg, Object... arguments) {
 207                 // no-op
 208             }
 209
 210             @Override
 211             public void error(String msg, Throwable t) {
 212                 // no-op
 213             }
 214         }
 215
 216         @Override
 217         public Logger getLogger(String className) {
 218             Objects.requireNonNull(className, "Name cannot be null");
 219             return NoOpLogger.INSTANCE;
 220         }
 221
 222         @Override
 223         public Logger getLogger(Class<?> clazz) {
 224             Objects.requireNonNull(clazz, "Class cannot be null");
 225             return NoOpLogger.INSTANCE;
 226         }
 227     }
 228 }
 229