gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2017 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.servlet;
  18
  19 import org.openecomp.sdc.logging.api.Logger;
  20 import org.openecomp.sdc.logging.api.LoggerFactory;
  21 import org.slf4j.MDC;
  22
  23 import javax.servlet.*;
  24 import javax.servlet.http.HttpServletRequest;
  25 import java.io.IOException;
  26 import java.net.InetAddress;
  27 import java.net.UnknownHostException;
  28 import java.util.UUID;
  29 import java.util.concurrent.atomic.AtomicLong;
  30
  31
  32 /**
  33  *
  34  * <p>Pushes information required by EELF onto MDC (Mapped Diagnostic Context).</p>
  35  *
  36  * <p>This is servlet filter that should be configured in <i>web.xml</i> to be used. Example:</p>
  37  *
  38  * <pre>
  39  *
  40  *  &lt;filter&gt;
  41  *      &lt;filter-name&gt;LoggingServletFilter&lt;/filter-name&gt;
  42  *      &lt;filter-class&gt;org.openecomp.sdc.logging.servlet.LoggingFilter&lt;/filter-class&gt;
  43  *  &lt;/filter&gt;
  44  *
  45  *  &lt;filter-mapping&gt;
  46  *      &lt;filter-name&gt;LoggingServletFilter&lt;/filter-name&gt;
  47  *      &lt;url-pattern&gt;/*&lt;/url-pattern&gt;
  48  *  &lt;/filter-mapping&gt;
  49  *
  50  * </pre>
  51  *
  52  * @author evitaliy
  53  * @since 25/07/2016.
  54  */
  55 public class LoggingFilter implements Filter {
  56
  57     // should be cashed to avoid low-level call, but with a timeout to account for IP or FQDN changes
  58     private static final HostAddressCache HOST_ADDRESS = new HostAddressCache();
  59     private static final String UNKNOWN = "UNKNOWN";
  60
  61     private final static Logger LOGGER = LoggerFactory.getLogger(LoggingFilter.class);
  62
  63     public void destroy() {
  64     }
  65
  66     public void doFilter(ServletRequest request, ServletResponse response,
  67                          FilterChain chain) throws IOException, ServletException {
  68
  69         try {
  70
  71             MDC.clear();
  72
  73             MDC.put("RequestId", UUID.randomUUID().toString());
  74             MDC.put("ServiceInstanceId", "N/A"); // not applicable
  75             MDC.put("ServiceName", "ASDC");
  76             MDC.put("InstanceUUID", "N/A");
  77
  78             // For some reason chooses IPv4 or IPv6 in a random way
  79             MDC.put("RemoteHost", request.getRemoteHost());
  80
  81             InetAddress host = HOST_ADDRESS.get();
  82
  83             String ipAddress, hostName;
  84             if (host == null) {
  85                 ipAddress = UNKNOWN;
  86                 hostName = UNKNOWN;
  87             } else {
  88                 ipAddress = host.getHostAddress();
  89                 hostName = host.getHostName();
  90             }
  91
  92             MDC.put("ServerIPAddress", ipAddress);
  93             MDC.put("ServerFQDN", hostName);
  94
  95             if(request instanceof HttpServletRequest) {
  96                 String userName = ((HttpServletRequest) request).getHeader("USER_ID");
  97                 MDC.put("PartnerName", userName);
  98             }
  99             // TODO: Clarify what these stand for
 100     //        MDC.put("AlertSeverity", );
 101     //        MDC.put("Timer", );
 102
 103             chain.doFilter(request, response);
 104
 105         } finally {
 106             MDC.clear();
 107         }
 108     }
 109
 110     public void init(FilterConfig config) throws ServletException { }
 111
 112     private static class HostAddressCache {
 113
 114         private static final long REFRESH_TIME = 1000L;
 115
 116         private final AtomicLong lastUpdated = new AtomicLong(0L);
 117         private InetAddress hostAddress;
 118
 119         public InetAddress get() {
 120
 121             long current = System.currentTimeMillis();
 122             if (current - lastUpdated.get() > REFRESH_TIME) {
 123
 124                 synchronized (this) {
 125
 126                     try {
 127                         lastUpdated.set(current); // set now to register the attempt even if failed
 128                         hostAddress = InetAddress.getLocalHost();
 129                     } catch (UnknownHostException e) {
 130                         LOGGER.error("Failed to retrieve local hostname for logging", e);
 131                         hostAddress = null;
 132                     }
 133                 }
 134             }
 135
 136             return hostAddress;
 137         }
 138     }
 139 }