/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.synapse.transport.http.access;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.Header;
import org.apache.http.HttpMessage;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.params.HttpParams;
import org.apache.synapse.transport.http.wrapper.HttpRequestWrapper;
import org.apache.synapse.transport.http.wrapper.HttpResponseWrapper;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentLinkedQueue;
/**
* The class to handle the HTTP Access Logs, patterns and the major functionality.
* Major Code segment borrowed from Apache Tomcat's
* org.apache.catalina.valves.AccessLogValve with thanks.
*/
public class Access {
private static Log log = LogFactory.getLog(Access.class);
/**
* Array of AccessLogElement, they will be used to make log message.
*/
protected AccessLogElement[] logElements = null;
protected String pattern = AccessConstants.getLogPattern();
private static AccessLogger accessLogger;
private static ConcurrentLinkedQueue<HttpRequestWrapper> requestQueue;
private static ConcurrentLinkedQueue<HttpResponseWrapper> responseQueue;
private static final int LOG_FREQUENCY_IN_SECONDS = 30;
private Date date;
/**
* Constructor of AccessLog. AccessHandler has a static object of Access.
*
* @param log - Log passed as a param. Default is Log of the same class.
* @param accessLogger - AccessLogger Object
*/
public Access(final Log log, AccessLogger accessLogger) {
super();
Access.log = log;
Access.accessLogger = accessLogger;
requestQueue = new ConcurrentLinkedQueue<HttpRequestWrapper>();
responseQueue = new ConcurrentLinkedQueue<HttpResponseWrapper>();
logElements = createLogElements();
logAccesses();
}
/**
* Adds the accesses to the queue.
*
* @param request - HttpRequest
*/
public void addAccessToQueue(HttpRequest request) {
HttpRequestWrapper requestWrapper = new HttpRequestWrapper();
requestWrapper.setHttpRequest(request);
requestWrapper.setDate(new Date(AccessTimeUtil.getDate().getTime()));
requestQueue.add(requestWrapper);
}
/**
* Adds the accesses to the queue.
*
* @param response - HttpResponse
*/
public void addAccessToQueue(HttpResponse response) {
HttpResponseWrapper responseWrapper = new HttpResponseWrapper();
responseWrapper.setHttpResponse(response);
responseWrapper.setDate(new Date(AccessTimeUtil.getDate().getTime()));
responseQueue.add(responseWrapper);
}
/**
* logs the request and response accesses.
*/
public void logAccesses() {
TimerTask logRequests = new LogRequests();
TimerTask logResponses = new LogResponses();
Timer requestTimer = new Timer();
Timer responseTimer = new Timer();
// Retry in 30 seconds
long retryIn = 1000 * LOG_FREQUENCY_IN_SECONDS;
requestTimer.schedule(logRequests, 0, retryIn);
responseTimer.schedule(logResponses, 0, retryIn);
}
private class LogRequests extends TimerTask {
public void run() {
while (!requestQueue.isEmpty()) {
HttpRequestWrapper req = requestQueue.poll();
log(req, null);
}
}
}
private class LogResponses extends TimerTask {
public void run() {
while (!responseQueue.isEmpty()) {
HttpResponseWrapper res = responseQueue.poll();
log(null, res);
}
}
}
/**
* The log method that is called from the NHttpClient and Server connection classes.
*
* @param request - HttpRequest
* @param response - HttpResponse
*/
public void log(HttpRequest request, HttpResponse response) {
date = AccessTimeUtil.getDate();
//String commonLogFormatDate = AccessTimeUtil.getAccessDate(date);
StringBuilder result = new StringBuilder(128);
for (AccessLogElement logElement : logElements) {
logElement.addElement(result, date, request, response);
}
String logString = result.toString();
log.debug(logString); //log to the console
accessLogger.log(logString); //log to the file
}
/**
* gets the header values from the given message, with the given name.
*
* @param message - The message, HttpRequest or HttpResponse
* @param name - The header, which we need to get the value of.
* @return - The header value.
*/
protected static String getHeaderValues(HttpMessage message, String name) {
int length = 0;
Header[] header = new Header[0];
StringBuffer headerValue = new StringBuffer();
try {
header = message.getHeaders(name);
length = header.length;
} catch (Exception e) {
// The header doesn't exist
}
if (length == 0) {
return "-";
} else if (length == 1) {
return header[0].getValue();
} else {
headerValue.append(header[0].getValue());
for (int i = 1; i < length; i++) {
headerValue.append(" - ").append(header[i].getValue());
}
}
return headerValue.toString();
}
protected static String getParam(HttpMessage message, String paramName) {
HttpParams params = message.getParams();
String param = (String) params.getParameter(paramName);
if (param == null) {
param = "-";
}
return param;
}
public static String getHostElement(HttpMessage message) {
return getHeaderValues(message, "Host"); //%h;
}
public static String getLogicalUserNameElement(HttpMessage message) {
if (message != null) { //%l
return "-";
}
return "";
}
public static String getUserNameElement(HttpMessage message) {
return getHeaderValues(message, "From"); //%u
}
public static String getCookieElement(HttpMessage message) {
return getHeaderValues(message, "Cookie"); // %c
}
public static String getRefererElement(HttpMessage message) {
return getHeaderValues(message, "Referer"); //%{Referer}i; %f
}
public static String getUserAgentElement(HttpMessage message) {
return getHeaderValues(message, "User-Agent"); //%{User-Agent} %a
}
public static String getAcceptElement(HttpMessage message) {
return getHeaderValues(message, "Accept");
}
public static String getAcceptLanguageElement(HttpMessage message) {
return getHeaderValues(message, "Accept-Language");
}
public static String getAcceptEncodingElement(HttpMessage message) {
return getHeaderValues(message, "Accept-Encoding");
}
public static String getAcceptCharSetElement(HttpMessage message) {
return getHeaderValues(message, "Accept-Charset");
}
public static String getConnectionElement(HttpMessage message) {
return getHeaderValues(message, "Connection"); //Keep-Alive
}
public static String getContentTypeElement(HttpMessage message) {
return getHeaderValues(message, "Content-Type");
}
public static String getKeepAliveElement(HttpMessage message) {
return getHeaderValues(message, "Keep-Alive");
}
public static String getTransferEncodingElement(HttpMessage message) {
return getHeaderValues(message, "Transfer-Encoding");
}
public static String getContentEncodingElement(HttpMessage message) {
return getHeaderValues(message, "Content-Encoding");
}
public static String getVaryElement(HttpMessage message) {
return getHeaderValues(message, "Vary");
}
public static String getServerElement(HttpMessage message) {
return getHeaderValues(message, "Server");
}
public static String getRemoteAddr(HttpMessage message) {
return getParam(message, "http.remote.addr");
}
/**
* AccessLogElement writes the partial message into the buffer.
*/
protected interface AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response);
}
/**
* write local IP address - %A
*/
protected static class LocalAddrElement implements AccessLogElement {
private static final String LOCAL_ADDR_VALUE;
static {
String init;
try {
init = InetAddress.getLocalHost().getHostAddress();
} catch (Throwable e) {
AccessTimeUtil.handleThrowable(e);
init = "127.0.0.1";
}
LOCAL_ADDR_VALUE = init;
}
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(LOCAL_ADDR_VALUE);
}
}
/**
* write remote host name - %h
*/
protected static class HostElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
String remoteHost = "-";
try {
if (request != null) {
remoteHost = getRemoteAddr(request);
} else if (response != null) {
remoteHost = getRemoteAddr(response);
}
} catch (Exception e) {
// empty host
}
buf.append(remoteHost);
}
}
/**
* write remote logical username from identd (always returns '-') - %l
*/
protected static class LogicalUserNameElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
String logicalUserName = "";
try {
logicalUserName = getLogicalUserNameElement(request);
} catch (Exception e) {
// empty logicalUserName
}
buf.append(logicalUserName);
}
}
/**
* write remote user that was authenticated (if any), else '-' - %u
*/
protected static class UserElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
String userElement = "";
try {
userElement = getUserNameElement(request);
} catch (Exception e) {
// empty UserName
}
buf.append(userElement);
}
}
/**
* write date and time, in Common Log Format - %t
*/
protected class DateAndTimeElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
String currentDate = AccessTimeUtil.getAccessDate(date);
buf.append(currentDate);
}
}
/**
* write first line of the request (method and request URI) - %r
*/
protected static class RequestElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
if (request != null) {
String requestLine = request.getRequestLine().toString();
buf.append(requestLine);
} else {
buf.append("- - ");
}
}
}
/**
* write HTTP status code of the response - %s
*/
protected static class HttpStatusCodeElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
if (response != null) {
int statusCode = response.getStatusLine().getStatusCode();
buf.append(statusCode); //getStatus
} else {
buf.append('-');
}
}
}
/**
* write bytes sent, excluding HTTP headers - %b, %B
*/
protected static class ByteSentElement implements AccessLogElement {
private boolean conversion;
/**
* if conversion is true, write '-' instead of 0 - %b
*
* @param conversion - To be conversed.
*/
public ByteSentElement(boolean conversion) {
this.conversion = conversion;
}
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
// Don't need to flush since trigger for log message is after the
// response has been committed
long length = -1;
try {
if (request != null) {
String sLength = getHeaderValues(request, "Content-Length");
if(null != sLength && !"".equals(sLength)) {
length = Long.valueOf(sLength);
}
} else if (response != null) {
length = response.getEntity().getContentLength(); //getBytesWritten(false);
}
if (length <= 0 && conversion) {
buf.append('-'); //%b
} else {
buf.append(length);
}
} catch (Exception e) {
buf.append('-'); //No entity found.
}
}
}
/**
* write request method (GET, POST, etc.) - %m
*/
protected static class MethodElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
if (request != null) {
buf.append(request.getRequestLine().getMethod());
}
}
}
/**
* write requested URL path - %U
*/
protected static class RequestURIElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
if (request != null) {
buf.append(request.getRequestLine().getUri());
} else {
buf.append('-');
}
}
}
/**
* write local server name - %v
*/
protected static class LocalServerNameElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getHeaderValues(request, "server"));
}
}
/**
* write any string
*/
protected static class StringElement implements AccessLogElement {
private String str;
public StringElement(String str) {
this.str = str;
}
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(str);
}
}
/**
* write incoming headers - %{xxx}i
*/
protected static class HeaderElement implements AccessLogElement {
private String header;
public HeaderElement(String header) {
this.header = header;
}
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
try {
String value = getHeaderValues(request, header);
if (value == null) {
buf.append('-');
} else {
buf.append(value);
}
} catch (Exception e) {
buf.append('-'); //Header is null
}
}
}
/**
* write a specific cookie - %{xxx}c
*/
protected static class CookieElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getCookieElement(request));
}
}
/**
* write the referer - %f
*/
protected static class RefererElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getRefererElement(request));
}
}
/**
* write the user agent - %a
*/
protected static class UserAgentElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getUserAgentElement(request));
}
}
/**
* write the Accept Element - %C
*/
protected static class AcceptElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getAcceptElement(request));
}
}
/**
* write the Accept Language Element - %L
*/
protected static class AcceptLanguageElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getAcceptLanguageElement(request));
}
}
/**
* write the Accept Encoding Element - %e
*/
protected static class AcceptEncodingElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getAcceptEncodingElement(request));
}
}
/**
* write the Accept Character Set Element - %S
*/
protected static class AcceptCharSetElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getAcceptCharSetElement(request));
}
}
/**
* write the Connection Element - %x
*/
protected static class ConnectionElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getConnectionElement(request));
}
}
/**
* write the Content Type Element - %T
*/
protected static class ContentTypeElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getContentTypeElement(request));
}
}
/**
* write the Keep Alive Element - %k
*/
protected static class KeepAliveElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getKeepAliveElement(request));
}
}
/**
* write the Transfer Encoding Element - %E
*/
protected static class TransferEncodingElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getTransferEncodingElement(request));
}
}
/**
* write the Content Encoding Element - %n
*/
protected static class ContentEncodingElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getContentEncodingElement(request));
}
}
/**
* write the Vary Element - %V
*/
protected static class VaryElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getVaryElement(request));
}
}
/**
* write the Server Element - %Z
*/
protected static class ServerElement implements AccessLogElement {
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
buf.append(getServerElement(request));
}
}
/**
* write a specific response header - %{xxx}o
*/
protected static class ResponseHeaderElement implements AccessLogElement {
private String header;
public ResponseHeaderElement(String header) {
this.header = header;
}
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
if (null != response) {
buf.append(getHeaderValues(response, header));
}
buf.append("-");
}
}
/**
* write an attribute in the ServletRequest - %{xxx}r %R
*/
protected static class RequestAttributeElement implements AccessLogElement {
public RequestAttributeElement() {
}
public void addElement(StringBuilder buf, Date date, HttpRequest request,
HttpResponse response) {
Object value;
if (request != null) {
value = request.getLastHeader(buf.toString()); //gets the attribute header
} else {
value = "??";
}
if (value != null) {
if (value instanceof String) {
buf.append((String) value);
} else {
buf.append(value.toString());
}
} else {
buf.append('-');
}
}
}
/**
* parse pattern string and create the array of AccessLogElement
*
* @return Array of AccessLogElement
*/
protected AccessLogElement[] createLogElements() {
List<AccessLogElement> list = new ArrayList<AccessLogElement>();
boolean replace = false;
StringBuilder buf = new StringBuilder();
for (int i = 0; i < pattern.length(); i++) {
char ch = pattern.charAt(i);
if (replace) {
/*
* For code that processes {, the behavior will be ... if I do
* not encounter a closing } - then I ignore the {
*/
if ('{' == ch) {
StringBuilder name = new StringBuilder();
int j = i + 1;
for (; j < pattern.length() && '}' != pattern.charAt(j); j++) {
name.append(pattern.charAt(j));
}
if (j + 1 < pattern.length()) {
/* the +1 was to account for } which we increment now */
j++;
list.add(createAccessLogElement(name.toString(),
pattern.charAt(j)));
i = j; /* Since we walked more than one character */
} else {
// D'oh - end of string - pretend we never did this
// and do processing the "old way"
list.add(createAccessLogElement(ch));
}
} else {
list.add(createAccessLogElement(ch));
}
replace = false;
} else if (ch == '%') {
replace = true;
list.add(new StringElement(buf.toString()));
buf = new StringBuilder();
} else {
buf.append(ch);
}
}
if (buf.length() > 0) {
list.add(new StringElement(buf.toString()));
}
return list.toArray(new AccessLogElement[list.size()]);
}
/**
* create an AccessLogElement implementation which needs header string
*
* @param header - header of the request/response
* @param pattern - pattern character given for the input element
* @return AccessLogElement - accessLogElement
*/
private AccessLogElement createAccessLogElement(String header, char pattern) {
switch (pattern) {
case 'i':
return new HeaderElement(header); //%{xxx}i
case 'o':
return new ResponseHeaderElement(header);
case 'R':
return new RequestAttributeElement();
default:
return new StringElement("???");
}
}
/**
* create an AccessLogElement implementation
*
* @param pattern - pattern character given for the input element
* @return AccessLogElement acceessLogElement
*/
private AccessLogElement createAccessLogElement(char pattern) {
switch (pattern) {
case 'A':
return new LocalAddrElement();
case 'a':
return new UserAgentElement();
case 'b':
return new ByteSentElement(true); //%b
case 'B':
return new ByteSentElement(false);
case 'c':
return new CookieElement(); // %c
case 'C':
return new AcceptElement();
case 'e':
return new AcceptEncodingElement();
case 'E':
return new TransferEncodingElement();
case 'f':
return new RefererElement();
case 'h':
return new HostElement(); //%h
case 'k':
return new KeepAliveElement();
case 'l':
return new LogicalUserNameElement(); //%l
case 'L':
return new AcceptLanguageElement();
case 'm':
return new MethodElement();
case 'n':
return new ContentEncodingElement();
case 'r':
return new RequestElement(); //%r
case 'S':
return new AcceptCharSetElement();
case 's':
return new HttpStatusCodeElement(); // %s
case 'T':
return new ContentTypeElement();
case 't':
return new DateAndTimeElement(); //%t
case 'u':
return new UserElement(); //%u
case 'U':
return new RequestURIElement();
case 'V':
return new VaryElement();
case 'v':
return new LocalServerNameElement();
case 'x':
return new ConnectionElement();
case 'Z':
return new ServerElement();
default:
return new StringElement("???" + pattern + "???");
}
}
/**
* The log method that is called from the NHttpClient and Server connection classes.
* This method is used to log the request/response with the actual date of operation.
*
* @param request - HttpRequestWrapper
* @param response - HttpResponseWrapper
*/
public void log(HttpRequestWrapper request, HttpResponseWrapper response) {
Date actualDateOfOperation = null;
if(request != null) {
actualDateOfOperation = request.getDate();
} else if (response != null){
actualDateOfOperation = response.getDate();
}
StringBuilder result = new StringBuilder(128);
for (AccessLogElement logElement : logElements) {
if (request != null) {
logElement.addElement(result, actualDateOfOperation, request.getHttpRequest(), null);
} else if (response != null) {
logElement.addElement(result, actualDateOfOperation, null, response.getHttpResponse());
}
}
String logString = result.toString();
log.debug(logString); //log to the console
accessLogger.log(logString); //log to the file
}
}