Fixed below sonar issues.

Removed most of the checkstyle issues.
Hadled null pointer exception for log.
removed unwanted variables.

Issue-Id:AAI-211

Change-Id: I5d12e06f989f4b1f948a632806fa1eb4dd81280e
Signed-off-by: Bharat saraswal <bharat.saraswal@huawei.com>

1 files changed, 298 insertions, 289 deletions

diff --git a/eelf-logging/src/main/java/org/onap/aai/cl/eelf/AaiLoggerAdapter.java b/eelf-logging/src/main/java/org/onap/aai/cl/eelf/AaiLoggerAdapter.java
index adcdd3f..88b2f11 100644
--- a/eelf-logging/src/main/java/org/onap/aai/cl/eelf/AaiLoggerAdapter.java
+++ b/eelf-logging/src/main/java/org/onap/aai/cl/eelf/AaiLoggerAdapter.java
@@ -26,326 +26,335 @@ import com.att.eelf.configuration.EELFLogger;
 import com.att.eelf.configuration.EELFLogger.Level;
 import com.att.eelf.i18n.EELFResolvableErrorEnum;
 import com.att.eelf.i18n.EELFResourceManager;
-
 import org.onap.aai.cl.api.LogFields;
 import org.onap.aai.cl.api.LogLine;
-import org.onap.aai.cl.api.Logger;
 import org.onap.aai.cl.api.LogLine.LogLineType;
+import org.onap.aai.cl.api.Logger;
 import org.onap.aai.cl.mdc.MdcOverride;
 
-import java.util.HashMap;
-import java.util.Map;
-
 /**
  * This class provides a logging implementation which wraps the EELF logging
  * framework.
  */
 public class AaiLoggerAdapter implements Logger {
 
-  public static final String BAD_ENUM_MSG = "UNRECOGNIZABLE ERROR CODE ";
-
-  /** Field name to use for the message portion of our log lines. */
-  public static final String MESSAGE_PREFIX = "Msg";
-
-  /**
-   * A place holder to use for fields in the standardized log message that we
-   * are not explicitly setting.
-   */
-  public static final String NOT_APPLICABLE = "na";
-
-  /**
-   * The instance of the actual EELF logger that we will be sending our messages
-   * to.
-   */
-  private EELFLogger eelfLogger;
-
-  /**
-   * This indicates the logging format type. It is used for deciding the string
-   * builder for constructing standardized log statements.
-   */
-  private LogLineType logLineType;
-
-  /** An identifier for the component that is generating the log statements. */
-  private String component = NOT_APPLICABLE;
-
-  /**
-   * Creates a new instance of the {@link AaiLoggerAdapter}, backed by the
-   * supplied {@link EELFLogger} instance.
-   * 
-   * @param eelfLogger
-   *          - The instance of {@link EELFLogger} that this logger will invoke.
-   */
-  public AaiLoggerAdapter(EELFLogger eelfLogger, LogLineType logLineType, String componentName) {
-
-    // Store the supplied EELFLogger instance.
-    this.eelfLogger = eelfLogger;
-    this.logLineType = logLineType;
-    this.component = componentName;
-  }
-
-  @Override
-  public boolean isTraceEnabled() {
-    return eelfLogger.isTraceEnabled();
-  }
-
-  @Override
-  public boolean isInfoEnabled() {
-    return eelfLogger.isInfoEnabled();
-  }
-
-  @Override
-  public boolean isErrorEnabled() {
-    return eelfLogger.isErrorEnabled();
-  }
-
-  @Override
-  public boolean isWarnEnabled() {
-    return eelfLogger.isWarnEnabled();
-  }
-
-  @Override
-  public boolean isDebugEnabled() {
-    return eelfLogger.isDebugEnabled();
-  }
-
-  /**
-   * Sets a number of the common fields which prefix all standard log
-   * statements.
-   */
-  private void initLogLine(LogLine logLine, String level, String logCode, String msg,
-      LogFields fields) {
-    logLine.init(component, logCode, level, msg, fields, new MdcOverride());
-  }
-
-  private void initLogLine(LogLine logLine, String level, String logCode, String msg,
-      LogFields fields, MdcOverride override) {
-    logLine.init(component, logCode, level, msg, fields, override);
-  }
-
-  @Override
-  public void info(Enum logCode, String... arguments) {
-    info(logCode, new LogFields(), arguments);
-  }
-
-  @Override
-  public void info(Enum logCode, LogFields fields, String... arguments) {
-
-    // We expect our error code to be compatible with the templating
-    // functionality provided by the EELF framework, so make sure
-    // that this is the case before we try to decode our error code.
-    if (logCode instanceof LogMessageEnum) {
-      // Cast our error code enum to make the EELF framework happy.
-      LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
-
-      // Initialize the log line
-      LogLine logLine = getLogLine();
-      initLogLine(logLine, Level.INFO.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
-          EELFResourceManager.format(eelfLogCode, arguments),
-          (fields == null) ? new LogFields() : fields);
-
-      // Pass our log string to the EELF logging framework.
-      eelfLogger.info(logLine.getFormattedLine());
-    } else {
-      eelfLogger.error(BAD_ENUM_MSG + logCode.toString());
+    public static final String BAD_ENUM_MSG = "UNRECOGNIZABLE ERROR CODE ";
+
+    /** Field name to use for the message portion of our log lines. */
+    public static final String MESSAGE_PREFIX = "Msg";
+
+    /**
+     * A place holder to use for fields in the standardized log message that we
+     * are not explicitly setting.
+     */
+    private static final String NOT_APPLICABLE = "na";
+
+    /**
+     * The instance of the actual EELF logger that we will be sending our messages
+     * to.
+     */
+    private final EELFLogger eelfLogger;
+
+    /**
+     * This indicates the logging format type. It is used for deciding the string
+     * builder for constructing standardized log statements.
+     */
+    private final LogLineType logLineType;
+
+    /** An identifier for the component that is generating the log statements. */
+    private String component = NOT_APPLICABLE;
+
+    /**
+     * Creates a new instance of the {@link AaiLoggerAdapter}, backed by the
+     * supplied {@link EELFLogger} instance.
+     *
+     * @param eelfLogger
+     *          - The instance of {@link EELFLogger} that this logger will invoke.
+     */
+    public AaiLoggerAdapter(EELFLogger eelfLogger, LogLineType logLineType, String componentName) {
+
+        // Store the supplied EELFLogger instance.
+        this.eelfLogger = eelfLogger;
+        this.logLineType = logLineType;
+        component = componentName;
     }
-  }
-
-  @Override
-  public void info(Enum logCode, LogFields fields, MdcOverride override, String... arguments) {
-
-    // We expect our error code to be compatible with the templating
-    // functionality provided by the EELF framework, so make sure
-    // that this is the case before we try to decode our error code.
-    if (logCode instanceof LogMessageEnum) {
-      // Cast our error code enum to make the EELF framework happy.
-      LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
-
-      // Initialize the log line
-      LogLine logLine = getLogLine();
-      initLogLine(logLine, Level.INFO.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
-          EELFResourceManager.format(eelfLogCode, arguments),
-          (fields == null) ? new LogFields() : fields, override);
-
-      // Pass our log string to the EELF logging framework.
-      eelfLogger.info(logLine.getFormattedLine());
-    } else {
-      eelfLogger.error(BAD_ENUM_MSG + logCode.toString());
+
+    @Override
+    public boolean isTraceEnabled() {
+        return eelfLogger.isTraceEnabled();
     }
-  }
-
-  @Override
-  public void debug(String message) {
-    // Initialize the log line
-    LogLine logLine = getLogLine();
-    initLogLine(logLine, Level.DEBUG.toString(), "", message, new LogFields());
-
-    // Pass our log string the the EELF logging framework.
-    eelfLogger.debug(logLine.getFormattedLine());
-  }
-
-  @Override
-  public void debug(Enum logCode, String... arguments) {
-    debug(logCode, new LogFields(), arguments);
-  }
-
-  @Override
-  public void debug(Enum logCode, LogFields fields, String... arguments) {
-
-    // We expect our log code to be compatible with the templating
-    // functionality provided by the EELF framework, so make sure
-    // that this is the case before we try to decode it.
-    if (logCode instanceof LogMessageEnum) {
-      // Cast our error code enum to make the EELF framework happy.
-      LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
-
-      // Initialize the log lineLogLine logLine = getLogLine();
-      LogLine logLine = getLogLine();
-      initLogLine(logLine, Level.DEBUG.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
-          EELFResourceManager.format(eelfLogCode, arguments),
-          (fields == null) ? new LogFields() : fields);
-
-      // Pass our log string to the EELF logging framework.
-      eelfLogger.debug(logLine.getFormattedLine());
-    } else {
-      eelfLogger.error(BAD_ENUM_MSG + logCode.toString());
+
+    @Override
+    public boolean isInfoEnabled() {
+        return eelfLogger.isInfoEnabled();
     }
-  }
-
-  @Override
-  public void warn(Enum logCode, String... arguments) {
-    warn(logCode, new LogFields(), arguments);
-  }
-
-  @Override
-  public void warn(Enum logCode, LogFields fields, String... arguments) {
-
-    // We expect our log code to be compatible with the templating
-    // functionality provided by the EELF framework, so make sure
-    // that this is the case before we try to decode our it.
-    if (logCode instanceof LogMessageEnum) {
-      // Cast our error code enum to make the EELF framework happy.
-      LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
-
-      // Initialize the log line
-      LogLine logLine = getLogLine();
-      initLogLine(logLine, Level.WARN.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
-          EELFResourceManager.format(eelfLogCode, arguments),
-          (fields == null) ? new LogFields() : fields);
-
-      // Pass our log string to the EELF logging framework.
-      eelfLogger.warn(logLine.getFormattedLine());
-    } else {
-      eelfLogger.error(BAD_ENUM_MSG + logCode.toString());
+
+    @Override
+    public boolean isErrorEnabled() {
+        return eelfLogger.isErrorEnabled();
     }
-  }
-
-  @Override
-  public void trace(Enum logCode, String... arguments) {
-    trace(logCode, new LogFields(), arguments);
-  }
-
-  @Override
-  public void trace(Enum logCode, LogFields fields, String... arguments) {
-
-    // We expect our log code to be compatible with the templating
-    // functionality provided by the EELF framework, so make sure
-    // that this is the case before we try to decode our it.
-    if (logCode instanceof LogMessageEnum) {
-      // Cast our error code enum to make the EELF framework happy.
-      LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
-
-      // Initialize the log line
-      LogLine logLine = getLogLine();
-      initLogLine(logLine, Level.TRACE.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
-          EELFResourceManager.format(eelfLogCode, arguments),
-          (fields == null) ? new LogFields() : fields);
-
-      // Pass our log string to the EELF logging framework.
-      eelfLogger.trace(logLine.getFormattedLine());
-
-    } else {
-      eelfLogger.error(BAD_ENUM_MSG + logCode.toString());
+
+    @Override
+    public boolean isWarnEnabled() {
+        return eelfLogger.isWarnEnabled();
     }
-  }
 
-  @Override
-  public void error(Enum logCode, String... arguments) {
-    error(logCode, new LogFields(), arguments);
-  }
+    @Override
+    public boolean isDebugEnabled() {
+        return eelfLogger.isDebugEnabled();
+    }
 
-  @Override
-  public void error(Enum logCode, LogFields fields, String... arguments) {
+    /**
+     * Sets a number of the common fields which prefix all standard log
+     * statements.
+     */
+    private void initLogLine(LogLine logLine, String level, String logCode, String msg,
+        LogFields fields) {
+        logLine.init(component, logCode, level, msg, fields, new MdcOverride());
+    }
+
+    private void initLogLine(LogLine logLine, String level, String logCode, String msg,
+        LogFields fields, MdcOverride override) {
+        logLine.init(component, logCode, level, msg, fields, override);
+    }
 
-    // We expect our log code to be compatible with the templating
-    // functionality provided by the EELF framework, so make sure
-    // that this is the case before we try to decode it.
-    if (logCode instanceof LogMessageEnum) {
+    @Override
+    public void info(Enum logCode, String... arguments) {
+        info(logCode, new LogFields(), arguments);
+    }
 
-      // Cast our error code enum to make the EELF framework happy.
-      LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
+    @Override
+    public void info(Enum logCode, LogFields fields, String... arguments) {
+
+        // We expect our error code to be compatible with the templating
+        // functionality provided by the EELF framework, so make sure
+        // that this is the case before we try to decode our error code.
+        if (logCode instanceof LogMessageEnum) {
+            // Cast our error code enum to make the EELF framework happy.
+            LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
+
+            // Initialize the log line
+            LogLine logLine = getLogLine();
+            if (logLine != null) {
+                initLogLine(logLine, Level.INFO.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
+                    EELFResourceManager.format(eelfLogCode, arguments),
+                    fields == null ? new LogFields() : fields);
+
+                // Pass our log string to the EELF logging framework.
+                eelfLogger.info(logLine.getFormattedLine());
+            }
+        } else {
+            eelfLogger.error(BAD_ENUM_MSG + logCode);
+        }
+    }
 
-      // Initialize the log line
-      LogLine logLine = getLogLine();
-      initLogLine(logLine, Level.ERROR.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
-          EELFResourceManager.format(eelfLogCode, arguments),
-          (fields == null) ? new LogFields() : fields);
+    @Override
+    public void info(Enum logCode, LogFields fields, MdcOverride override, String... arguments) {
+
+        // We expect our error code to be compatible with the templating
+        // functionality provided by the EELF framework, so make sure
+        // that this is the case before we try to decode our error code.
+        if (logCode instanceof LogMessageEnum) {
+            // Cast our error code enum to make the EELF framework happy.
+            LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
+
+            // Initialize the log line
+            LogLine logLine = getLogLine();
+            if (logLine != null) {
+                initLogLine(logLine, Level.INFO.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
+                    EELFResourceManager.format(eelfLogCode, arguments),
+                    fields == null ? new LogFields() : fields, override);
+
+                // Pass our log string to the EELF logging framework.
+                eelfLogger.info(logLine.getFormattedLine());
+            }
+        } else {
+            eelfLogger.error(BAD_ENUM_MSG + logCode);
+        }
+    }
 
-      // Pass our log string to the EELF logging framework.
-      eelfLogger.error(logLine.getFormattedLine());
+    @Override
+    public void debug(String message) {
+        // Initialize the log line
+        LogLine logLine = getLogLine();
+        if (logLine != null) {
+            initLogLine(logLine, Level.DEBUG.toString(), "", message, new LogFields());
 
-    } else {
-      eelfLogger.error(BAD_ENUM_MSG + logCode.toString());
+            // Pass our log string the the EELF logging framework.
+            eelfLogger.debug(logLine.getFormattedLine());
+        }
     }
-  }
-
-  @Override
-  public void error(Enum logCode, Throwable ex, String... arguments) {
-    error(logCode, new LogFields(), ex, arguments);
-  }
-
-  @Override
-  public void error(Enum logCode, LogFields fields, Throwable ex, String... arguments) {
-
-    // We expect our log code to be compatible with the templating
-    // functionality provided by the EELF framework, so make sure
-    // that this is the case before we try to decode it.
-    if (logCode instanceof LogMessageEnum) {
-      // Cast our error code enum to make the EELF framework happy.
-      LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
-
-      // Initialize the log line
-      LogLine logLine = getLogLine();
-      initLogLine(logLine, Level.ERROR.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
-          EELFResourceManager.format(eelfLogCode, arguments),
-          (fields == null) ? new LogFields() : fields);
-
-      // Pass our log string to the EELF logging framework.
-      eelfLogger.error(logLine.getFormattedLine(), ex);
-
-    } else {
-      eelfLogger.error(BAD_ENUM_MSG + logCode.toString());
+
+    @Override
+    public void debug(Enum logCode, String... arguments) {
+        debug(logCode, new LogFields(), arguments);
     }
-  }
 
-  @Override
-  public String formatMsg(Enum logCode, String... arguments) {
-    return EELFResourceManager.getMessage((EELFResolvableErrorEnum) logCode, arguments);
-  }
+    @Override
+    public void debug(Enum logCode, LogFields fields, String... arguments) {
+
+        // We expect our log code to be compatible with the templating
+        // functionality provided by the EELF framework, so make sure
+        // that this is the case before we try to decode it.
+        if (logCode instanceof LogMessageEnum) {
+            // Cast our error code enum to make the EELF framework happy.
+            LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
+
+            // Initialize the log lineLogLine logLine = getLogLine()
+            LogLine logLine = getLogLine();
+            if (logLine != null) {
+                initLogLine(logLine, Level.DEBUG.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
+                    EELFResourceManager.format(eelfLogCode, arguments),
+                    fields == null ? new LogFields() : fields);
+
+                // Pass our log string to the EELF logging framework.
+                eelfLogger.debug(logLine.getFormattedLine());
+            }
+        } else {
+            eelfLogger.error(BAD_ENUM_MSG + logCode);
+        }
+    }
 
-  private LogLine getLogLine() {
-    if (logLineType == LogLineType.AUDIT) {
-      return new AuditLogLine();
+    @Override
+    public void warn(Enum logCode, String... arguments) {
+        warn(logCode, new LogFields(), arguments);
     }
 
-    if (logLineType == LogLineType.ERROR) {
-      return new ErrorLogLine();
+    @Override
+    public void warn(Enum logCode, LogFields fields, String... arguments) {
+
+        // We expect our log code to be compatible with the templating
+        // functionality provided by the EELF framework, so make sure
+        // that this is the case before we try to decode our it.
+        if (logCode instanceof LogMessageEnum) {
+            // Cast our error code enum to make the EELF framework happy.
+            LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
+
+            // Initialize the log line
+            LogLine logLine = getLogLine();
+            if (logLine != null) {
+                initLogLine(logLine, Level.WARN.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
+                    EELFResourceManager.format(eelfLogCode, arguments),
+                    fields == null ? new LogFields() : fields);
+
+                // Pass our log string to the EELF logging framework.
+                eelfLogger.warn(logLine.getFormattedLine());
+            }
+        } else {
+            eelfLogger.error(BAD_ENUM_MSG + logCode);
+        }
     }
 
-    if (logLineType == LogLineType.METRICS) {
-      return new MetricsLogLine();
+    @Override
+    public void trace(Enum logCode, String... arguments) {
+        trace(logCode, new LogFields(), arguments);
     }
 
-    eelfLogger.warn("Unsupported LogLineType: " + logLineType);
-    return null;
-  }
+    @Override
+    public void trace(Enum logCode, LogFields fields, String... arguments) {
+
+        // We expect our log code to be compatible with the templating
+        // functionality provided by the EELF framework, so make sure
+        // that this is the case before we try to decode our it.
+        if (logCode instanceof LogMessageEnum) {
+            // Cast our error code enum to make the EELF framework happy.
+            LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
+
+            // Initialize the log line
+            LogLine logLine = getLogLine();
+            if (logLine != null) {
+                initLogLine(logLine, Level.TRACE.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
+                    EELFResourceManager.format(eelfLogCode, arguments),
+                    fields == null ? new LogFields() : fields);
+
+                // Pass our log string to the EELF logging framework.
+                eelfLogger.trace(logLine.getFormattedLine());
+            }
+        } else {
+            eelfLogger.error(BAD_ENUM_MSG + logCode);
+        }
+    }
+
+    @Override
+    public void error(Enum logCode, String... arguments) {
+        error(logCode, new LogFields(), arguments);
+    }
+
+    @Override
+    public void error(Enum logCode, LogFields fields, String... arguments) {
+
+        // We expect our log code to be compatible with the templating
+        // functionality provided by the EELF framework, so make sure
+        // that this is the case before we try to decode it.
+        if (logCode instanceof LogMessageEnum) {
+
+            // Cast our error code enum to make the EELF framework happy.
+            LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
+
+            // Initialize the log line
+            LogLine logLine = getLogLine();
+            if (logLine != null) {
+                initLogLine(logLine, Level.ERROR.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
+                    EELFResourceManager.format(eelfLogCode, arguments),
+                    fields == null ? new LogFields() : fields);
+
+                // Pass our log string to the EELF logging framework.
+                eelfLogger.error(logLine.getFormattedLine());
+            }
+        } else {
+            eelfLogger.error(BAD_ENUM_MSG + logCode);
+        }
+    }
+
+    @Override
+    public void error(Enum logCode, Throwable ex, String... arguments) {
+        error(logCode, new LogFields(), ex, arguments);
+    }
+
+    @Override
+    public void error(Enum logCode, LogFields fields, Throwable ex, String... arguments) {
+
+        // We expect our log code to be compatible with the templating
+        // functionality provided by the EELF framework, so make sure
+        // that this is the case before we try to decode it.
+        if (logCode instanceof LogMessageEnum) {
+            // Cast our error code enum to make the EELF framework happy.
+            LogMessageEnum eelfLogCode = (LogMessageEnum) logCode;
+
+            // Initialize the log line
+            LogLine logLine = getLogLine();
+            if (logLine != null) {
+                initLogLine(logLine, Level.ERROR.toString(), EELFResourceManager.getIdentifier(eelfLogCode),
+                    EELFResourceManager.format(eelfLogCode, arguments),
+                    fields == null ? new LogFields() : fields);
+
+                // Pass our log string to the EELF logging framework.
+                eelfLogger.error(logLine.getFormattedLine(), ex);
+            }
+        } else {
+            eelfLogger.error(BAD_ENUM_MSG + logCode);
+        }
+    }
+
+    @Override
+    public String formatMsg(Enum logCode, String... arguments) {
+        return EELFResourceManager.getMessage((EELFResolvableErrorEnum) logCode, arguments);
+    }
+
+    private LogLine getLogLine() {
+        if (logLineType == LogLineType.AUDIT) {
+            return new AuditLogLine();
+        }
+
+        if (logLineType == LogLineType.ERROR) {
+            return new ErrorLogLine();
+        }
+
+        if (logLineType == LogLineType.METRICS) {
+            return new MetricsLogLine();
+        }
+
+        eelfLogger.warn("Unsupported LogLineType: " + logLineType);
+        return null;
+    }
 }