aai-core/src/main/java/org/openecomp/aai/logging/LoggingContext.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * org.openecomp.aai
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.aai.logging;
  22
  23 import com.att.eelf.configuration.EELFLogger;
  24 import com.att.eelf.configuration.EELFManager;
  25 import org.json.JSONException;
  26 import org.json.JSONObject;
  27 import org.slf4j.MDC;
  28
  29 import java.net.InetAddress;
  30 import java.net.UnknownHostException;
  31 import java.util.Iterator;
  32 import java.util.UUID;
  33 import java.util.concurrent.TimeUnit;
  34
  35 public class LoggingContext {
  36
  37         public enum StatusCode {
  38                 COMPLETE,
  39                 ERROR
  40         }
  41
  42         private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(LoggingContext.class);
  43
  44         private static final String PREVIOUS_CONTEXT_KEY = "_PREVIOUS_CONTEXT";
  45
  46         //ECOMP Specific Log Event Fields
  47         public static enum LoggingField {
  48                 START_TIME("startTime"),
  49                 REQUEST_ID("requestId"),
  50                 SERVICE_INSTANCE_ID("serviceInstanceId"),
  51                 SERVER_NAME("serverName"),
  52                 SERVICE_NAME("serviceName"),
  53                 PARTNER_NAME("partnerName"),
  54                 STATUS_CODE("statusCode"),
  55                 RESPONSE_CODE("responseCode"),
  56                 RESPONSE_DESCRIPTION("responseDescription"),
  57                 INSTANCE_UUID("instanceUUID"),
  58                 SEVERITY("severity"),
  59                 SERVER_IP_ADDRESS("serverIpAddress"),
  60                 ELAPSED_TIME("elapsedTime"),
  61                 SERVER("server"),
  62                 CLIENT_IP_ADDRESS("clientIpAddress"),
  63                 UNUSED("unused"),
  64                 PROCESS_KEY("processKey"),
  65                 CUSTOM_FIELD_1("customField1"),
  66                 CUSTOM_FIELD_2("customField2"),
  67                 CUSTOM_FIELD_3("customField3"),
  68                 CUSTOM_FIELD_4("customField4"),
  69
  70                 //ECOMP Specific Metric Log Event Fields
  71                 TARGET_ENTITY("targetEntity"),
  72
  73                 //A&AI Specific Log Event Fields
  74                 COMPONENT("component"),
  75                 STOP_WATCH_START("stopWatchStart");
  76
  77                 private final String text;
  78
  79                 private LoggingField(final String text) {
  80                         this.text = text;
  81                 }
  82
  83                 public String toString() {
  84                         return text;
  85                 }
  86         }
  87
  88
  89         public static void init() {
  90                 LoggingContext.clear();
  91                 LoggingContext.startTime();
  92                 LoggingContext.server();
  93                 LoggingContext.serverIpAddress();
  94         }
  95
  96         private static void startTime() {
  97                 MDC.put(LoggingField.START_TIME.toString(), LogFormatTools.getCurrentDateTime());
  98         }
  99
 100         public static void requestId(UUID requestId) {
 101                 MDC.put(LoggingField.REQUEST_ID.toString(), requestId.toString());
 102         }
 103
 104         public static void requestId(String requestId) {
 105                 try {
 106                         MDC.put(LoggingField.REQUEST_ID.toString(), UUID.fromString(requestId).toString());
 107                 } catch (IllegalArgumentException e) {
 108                         final UUID generatedRequestUuid = UUID.randomUUID();
 109                         MDC.put(LoggingField.REQUEST_ID.toString(), generatedRequestUuid.toString());
 110                         LOGGER.warn("Unable to use UUID " + requestId + " (Not formatted properly). Using generated UUID=" + generatedRequestUuid);
 111                 }
 112         }
 113
 114         public static void serviceInstanceId(String serviceInstanceId) {
 115                 MDC.put(LoggingField.SERVICE_INSTANCE_ID.toString(), serviceInstanceId);
 116         }
 117
 118         public static void serverName(String serverName) {
 119                 MDC.put(LoggingField.SERVER_NAME.toString(), serverName);
 120         }
 121
 122         public static void serviceName(String serviceName) {
 123                 MDC.put(LoggingField.SERVICE_NAME.toString(), serviceName);
 124         }
 125
 126         public static void partnerName(String partnerName) {
 127                 MDC.put(LoggingField.PARTNER_NAME.toString(), partnerName);
 128         }
 129
 130         public static void statusCode(LoggingContext.StatusCode statusCode) {
 131                 MDC.put(LoggingField.STATUS_CODE.toString(), statusCode.toString());
 132         }
 133
 134         public static String responseCode() {
 135                 return (String) MDC.get(LoggingField.RESPONSE_CODE.toString());
 136         }
 137
 138         public static void responseCode(String responseCode) {
 139                 MDC.put(LoggingField.RESPONSE_CODE.toString(), responseCode);
 140         }
 141
 142         public static void responseDescription(String responseDescription) {
 143                 MDC.put(LoggingField.RESPONSE_DESCRIPTION.toString(), responseDescription);
 144         }
 145
 146         public static void instanceUuid(UUID instanceUuid) {
 147                 MDC.put(LoggingField.INSTANCE_UUID.toString(), instanceUuid.toString());
 148         }
 149
 150         public static void severity(int severity) {
 151                 MDC.put(LoggingField.SEVERITY.toString(), String.valueOf(severity));
 152         }
 153
 154         private static void serverIpAddress() {
 155                 try {
 156                         MDC.put(LoggingField.SERVER_IP_ADDRESS.toString(), InetAddress.getLocalHost().getHostAddress());
 157                 } catch (UnknownHostException e) {
 158                         LOGGER.warn("Unable to resolve server IP address - will not be displayed in logged events");
 159                 }
 160         }
 161
 162         public static void elapsedTime(long elapsedTime, TimeUnit timeUnit) {
 163                 MDC.put(LoggingField.ELAPSED_TIME.toString(), String.valueOf(TimeUnit.MILLISECONDS.convert(elapsedTime, timeUnit)));
 164         }
 165
 166         private static void server() {
 167                 try {
 168                         MDC.put(LoggingField.SERVER.toString(),  InetAddress.getLocalHost().getCanonicalHostName());
 169                 } catch (UnknownHostException e) {
 170                         LOGGER.warn("Unable to resolve server IP address - hostname will not be displayed in logged events");
 171                 }
 172         }
 173
 174         public static void clientIpAddress(InetAddress clientIpAddress) {
 175                 MDC.put(LoggingField.CLIENT_IP_ADDRESS.toString(), clientIpAddress.getHostAddress());
 176         }
 177
 178         public static void clientIpAddress(String clientIpAddress) {
 179                 try {
 180                         MDC.put(LoggingField.CLIENT_IP_ADDRESS.toString(), InetAddress.getByName(clientIpAddress).getHostAddress());
 181                 } catch (UnknownHostException e) {
 182                         //Ignore, will not be thrown since InetAddress.getByName(String) only
 183                         //checks the validity of the passed in string
 184                 }
 185         }
 186
 187         public static void unused(String unused) {
 188                 LOGGER.warn("Using field '" + LoggingField.UNUSED + "' (seems like this should go unused...)");
 189                 MDC.put(LoggingField.UNUSED.toString(), unused);
 190         }
 191
 192         public static void processKey(String processKey) {
 193                 MDC.put(LoggingField.PROCESS_KEY.toString(), processKey);
 194         }
 195
 196         public static void customField1(String customField1) {
 197                 MDC.put(LoggingField.CUSTOM_FIELD_1.toString(), customField1);
 198         }
 199
 200         public static void customField2(String customField2) {
 201                 MDC.put(LoggingField.CUSTOM_FIELD_2.toString(), customField2);
 202         }
 203
 204         public static void customField3(String customField3) {
 205                 MDC.put(LoggingField.CUSTOM_FIELD_3.toString(), customField3);
 206         }
 207
 208         public static void customField4(String customField4) {
 209                 MDC.put(LoggingField.CUSTOM_FIELD_4.toString(), customField4);
 210         }
 211
 212         public static void component(String component) {
 213                 MDC.put(LoggingField.COMPONENT.toString(), component);
 214         }
 215
 216         public static void targetEntity(String targetEntity) {
 217                 MDC.put(LoggingField.TARGET_ENTITY.toString(), targetEntity);
 218         }
 219
 220         public static void stopWatchStart() {
 221                 MDC.put(LoggingField.STOP_WATCH_START.toString(), String.valueOf(System.nanoTime()));
 222         }
 223
 224         public static double stopWatchStop() {
 225                 final long stopWatchEnd = System.nanoTime();
 226                 final Long stopWatchStart = Long.valueOf(MDC.get(LoggingField.STOP_WATCH_START.toString()));
 227
 228                 if (stopWatchStart == null) throw new StopWatchNotStartedException();
 229
 230                 MDC.remove(LoggingField.STOP_WATCH_START.toString());
 231
 232                 final double elapsedTimeMillis = (stopWatchEnd - stopWatchStart) / 1000.0 / 1000.0;
 233
 234                 LoggingContext.elapsedTime((long) elapsedTimeMillis, TimeUnit.MILLISECONDS);
 235
 236                 return elapsedTimeMillis;
 237         }
 238
 239         public static void put(String key, String value) {
 240                 MDC.put(key, value);
 241         }
 242
 243         public static void clear() {
 244                 MDC.clear();
 245         }
 246
 247         public static void remove(String key) {
 248                 MDC.remove(key);
 249         }
 250
 251         public static void save() {
 252                 final JSONObject context = new JSONObject();
 253
 254                 for (LoggingField field : LoggingField.values()) {
 255                         if (field == LoggingField.ELAPSED_TIME) continue;
 256
 257                         try {
 258                                 context.put(field.toString(), MDC.get(field.toString()));
 259                         } catch (JSONException e) {
 260                                 //Ignore - only occurs when the key is null (which can't happen)
 261                                 //                      or the value is invalid (everything is converted to a string
 262                                 //                      before it get put() to the MDC)
 263                         }
 264                 }
 265
 266                 MDC.put("_PREVIOUS_CONTEXT", context.toString());
 267         }
 268
 269         public static void restore() {
 270
 271                 final String rawPreviousContext = MDC.get(PREVIOUS_CONTEXT_KEY);
 272
 273                 if (rawPreviousContext == null) {
 274                         throw new LoggingContextNotExistsException();
 275                 }
 276
 277                 try {
 278                         final JSONObject previousContext = new JSONObject(rawPreviousContext);
 279
 280                         @SuppressWarnings("unchecked")
 281                         final Iterator<String> keys = previousContext.keys();
 282
 283                         while (keys.hasNext()) {
 284                                 final String key = keys.next();
 285
 286                                 try {
 287                                         MDC.put(key, previousContext.getString(key));
 288                                 } catch (JSONException e) {
 289                                         //Ignore, only occurs when the key is null (cannot happen)
 290                                         //                      or the value is invalid (they are all strings)
 291                                 }
 292                         }
 293
 294                         MDC.remove(PREVIOUS_CONTEXT_KEY);
 295                 } catch (JSONException e) {
 296                         //Ignore, the previousContext is serialized from a JSONObject
 297                 }
 298         }
 299 }