1 //
2 // ========================================================================
3 // Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
4 // ------------------------------------------------------------------------
5 // All rights reserved. This program and the accompanying materials
6 // are made available under the terms of the Eclipse Public License v1.0
7 // and Apache License v2.0 which accompanies this distribution.
8 //
9 // The Eclipse Public License is available at
10 // http://www.eclipse.org/legal/epl-v10.html
11 //
12 // The Apache License v2.0 is available at
13 // http://www.opensource.org/licenses/apache2.0.php
14 //
15 // You may elect to redistribute this code under either of these licenses.
16 // ========================================================================
17 //
18
19 package org.eclipse.jetty.server;
20
21 import java.io.IOException;
22 import java.io.OutputStream;
23 import java.io.OutputStreamWriter;
24 import java.io.Writer;
25 import java.util.Locale;
26 import java.util.TimeZone;
27
28 import javax.servlet.http.Cookie;
29
30 import org.eclipse.jetty.http.HttpHeaders;
31 import org.eclipse.jetty.http.PathMap;
32 import org.eclipse.jetty.util.DateCache;
33 import org.eclipse.jetty.util.RolloverFileOutputStream;
34 import org.eclipse.jetty.util.StringUtil;
35 import org.eclipse.jetty.util.component.AbstractLifeCycle;
36 import org.eclipse.jetty.util.log.Log;
37 import org.eclipse.jetty.util.log.Logger;
38
39 /**
40 * This {@link RequestLog} implementation outputs logs in the pseudo-standard
41 * NCSA common log format. Configuration options allow a choice between the
42 * standard Common Log Format (as used in the 3 log format) and the Combined Log
43 * Format (single log format). This log format can be output by most web
44 * servers, and almost all web log analysis software can understand these
45 * formats.
46 *
47 * @org.apache.xbean.XBean element="ncsaLog"
48 */
49
50 /* ------------------------------------------------------------ */
51 /**
52 */
53 public class NCSARequestLog extends AbstractLifeCycle implements RequestLog
54 {
55 private static final Logger LOG = Log.getLogger(NCSARequestLog.class);
56 private static ThreadLocal<StringBuilder> _buffers = new ThreadLocal<StringBuilder>()
57 {
58 @Override
59 protected StringBuilder initialValue()
60 {
61 return new StringBuilder(256);
62 }
63 };
64
65 private String _filename;
66 private boolean _extended;
67 private boolean _append;
68 private int _retainDays;
69 private boolean _closeOut;
70 private boolean _preferProxiedForAddress;
71 private String _logDateFormat = "dd/MMM/yyyy:HH:mm:ss Z";
72 private String _filenameDateFormat = null;
73 private Locale _logLocale = Locale.getDefault();
74 private String _logTimeZone = "GMT";
75 private String[] _ignorePaths;
76 private boolean _logLatency = false;
77 private boolean _logCookies = false;
78 private boolean _logServer = false;
79 private boolean _logDispatch = false;
80
81 private transient OutputStream _out;
82 private transient OutputStream _fileOut;
83 private transient DateCache _logDateCache;
84 private transient PathMap _ignorePathMap;
85 private transient Writer _writer;
86
87 /* ------------------------------------------------------------ */
88 /**
89 * Create request log object with default settings.
90 */
91 public NCSARequestLog()
92 {
93 _extended = true;
94 _append = true;
95 _retainDays = 31;
96 }
97
98 /* ------------------------------------------------------------ */
99 /**
100 * Create request log object with specified output file name.
101 *
102 * @param filename the file name for the request log.
103 * This may be in the format expected
104 * by {@link RolloverFileOutputStream}
105 */
106 public NCSARequestLog(String filename)
107 {
108 _extended = true;
109 _append = true;
110 _retainDays = 31;
111 setFilename(filename);
112 }
113
114 /* ------------------------------------------------------------ */
115 /**
116 * Set the output file name of the request log.
117 * The file name may be in the format expected by
118 * {@link RolloverFileOutputStream}.
119 *
120 * @param filename file name of the request log
121 *
122 */
123 public void setFilename(String filename)
124 {
125 if (filename != null)
126 {
127 filename = filename.trim();
128 if (filename.length() == 0)
129 filename = null;
130 }
131 _filename = filename;
132 }
133
134 /* ------------------------------------------------------------ */
135 /**
136 * Retrieve the output file name of the request log.
137 *
138 * @return file name of the request log
139 */
140 public String getFilename()
141 {
142 return _filename;
143 }
144
145 /* ------------------------------------------------------------ */
146 /**
147 * Retrieve the file name of the request log with the expanded
148 * date wildcard if the output is written to the disk using
149 * {@link RolloverFileOutputStream}.
150 *
151 * @return file name of the request log, or null if not applicable
152 */
153 public String getDatedFilename()
154 {
155 if (_fileOut instanceof RolloverFileOutputStream)
156 return ((RolloverFileOutputStream)_fileOut).getDatedFilename();
157 return null;
158 }
159
160 /* ------------------------------------------------------------ */
161 /**
162 * Set the timestamp format for request log entries in the file.
163 * If this is not set, the pre-formated request timestamp is used.
164 *
165 * @param format timestamp format string
166 */
167 public void setLogDateFormat(String format)
168 {
169 _logDateFormat = format;
170 }
171
172 /* ------------------------------------------------------------ */
173 /**
174 * Retrieve the timestamp format string for request log entries.
175 *
176 * @return timestamp format string.
177 */
178 public String getLogDateFormat()
179 {
180 return _logDateFormat;
181 }
182
183 /* ------------------------------------------------------------ */
184 /**
185 * Set the locale of the request log.
186 *
187 * @param logLocale locale object
188 */
189 public void setLogLocale(Locale logLocale)
190 {
191 _logLocale = logLocale;
192 }
193
194 /* ------------------------------------------------------------ */
195 /**
196 * Retrieve the locale of the request log.
197 *
198 * @return locale object
199 */
200 public Locale getLogLocale()
201 {
202 return _logLocale;
203 }
204
205 /* ------------------------------------------------------------ */
206 /**
207 * Set the timezone of the request log.
208 *
209 * @param tz timezone string
210 */
211 public void setLogTimeZone(String tz)
212 {
213 _logTimeZone = tz;
214 }
215
216 /* ------------------------------------------------------------ */
217 /**
218 * Retrieve the timezone of the request log.
219 *
220 * @return timezone string
221 */
222 public String getLogTimeZone()
223 {
224 return _logTimeZone;
225 }
226
227 /* ------------------------------------------------------------ */
228 /**
229 * Set the number of days before rotated log files are deleted.
230 *
231 * @param retainDays number of days to keep a log file
232 */
233 public void setRetainDays(int retainDays)
234 {
235 _retainDays = retainDays;
236 }
237
238 /* ------------------------------------------------------------ */
239 /**
240 * Retrieve the number of days before rotated log files are deleted.
241 *
242 * @return number of days to keep a log file
243 */
244 public int getRetainDays()
245 {
246 return _retainDays;
247 }
248
249 /* ------------------------------------------------------------ */
250 /**
251 * Set the extended request log format flag.
252 *
253 * @param extended true - log the extended request information,
254 * false - do not log the extended request information
255 */
256 public void setExtended(boolean extended)
257 {
258 _extended = extended;
259 }
260
261 /* ------------------------------------------------------------ */
262 /**
263 * Retrieve the extended request log format flag.
264 *
265 * @return value of the flag
266 */
267 public boolean isExtended()
268 {
269 return _extended;
270 }
271
272 /* ------------------------------------------------------------ */
273 /**
274 * Set append to log flag.
275 *
276 * @param append true - request log file will be appended after restart,
277 * false - request log file will be overwritten after restart
278 */
279 public void setAppend(boolean append)
280 {
281 _append = append;
282 }
283
284 /* ------------------------------------------------------------ */
285 /**
286 * Retrieve append to log flag.
287 *
288 * @return value of the flag
289 */
290 public boolean isAppend()
291 {
292 return _append;
293 }
294
295 /* ------------------------------------------------------------ */
296 /**
297 * Set request paths that will not be logged.
298 *
299 * @param ignorePaths array of request paths
300 */
301 public void setIgnorePaths(String[] ignorePaths)
302 {
303 _ignorePaths = ignorePaths;
304 }
305
306 /* ------------------------------------------------------------ */
307 /**
308 * Retrieve the request paths that will not be logged.
309 *
310 * @return array of request paths
311 */
312 public String[] getIgnorePaths()
313 {
314 return _ignorePaths;
315 }
316
317 /* ------------------------------------------------------------ */
318 /**
319 * Controls logging of the request cookies.
320 *
321 * @param logCookies true - values of request cookies will be logged,
322 * false - values of request cookies will not be logged
323 */
324 public void setLogCookies(boolean logCookies)
325 {
326 _logCookies = logCookies;
327 }
328
329 /* ------------------------------------------------------------ */
330 /**
331 * Retrieve log cookies flag
332 *
333 * @return value of the flag
334 */
335 public boolean getLogCookies()
336 {
337 return _logCookies;
338 }
339
340 /* ------------------------------------------------------------ */
341 /**
342 * Controls logging of the request hostname.
343 *
344 * @param logServer true - request hostname will be logged,
345 * false - request hostname will not be logged
346 */
347 public void setLogServer(boolean logServer)
348 {
349 _logServer = logServer;
350 }
351
352 /* ------------------------------------------------------------ */
353 /**
354 * Retrieve log hostname flag.
355 *
356 * @return value of the flag
357 */
358 public boolean getLogServer()
359 {
360 return _logServer;
361 }
362
363 /* ------------------------------------------------------------ */
364 /**
365 * Controls logging of request processing time.
366 *
367 * @param logLatency true - request processing time will be logged
368 * false - request processing time will not be logged
369 */
370 public void setLogLatency(boolean logLatency)
371 {
372 _logLatency = logLatency;
373 }
374
375 /* ------------------------------------------------------------ */
376 /**
377 * Retrieve log request processing time flag.
378 *
379 * @return value of the flag
380 */
381 public boolean getLogLatency()
382 {
383 return _logLatency;
384 }
385
386 /* ------------------------------------------------------------ */
387 /**
388 * Controls whether the actual IP address of the connection or
389 * the IP address from the X-Forwarded-For header will be logged.
390 *
391 * @param preferProxiedForAddress true - IP address from header will be logged,
392 * false - IP address from the connection will be logged
393 */
394 public void setPreferProxiedForAddress(boolean preferProxiedForAddress)
395 {
396 _preferProxiedForAddress = preferProxiedForAddress;
397 }
398
399 /* ------------------------------------------------------------ */
400 /**
401 * Retrieved log X-Forwarded-For IP address flag.
402 *
403 * @return value of the flag
404 */
405 public boolean getPreferProxiedForAddress()
406 {
407 return _preferProxiedForAddress;
408 }
409
410 /* ------------------------------------------------------------ */
411 /**
412 * Set the log file name date format.
413 * @see RolloverFileOutputStream#RolloverFileOutputStream(String, boolean, int, TimeZone, String, String)
414 *
415 * @param logFileDateFormat format string that is passed to {@link RolloverFileOutputStream}
416 */
417 public void setFilenameDateFormat(String logFileDateFormat)
418 {
419 _filenameDateFormat = logFileDateFormat;
420 }
421
422 /* ------------------------------------------------------------ */
423 /**
424 * Retrieve the file name date format string.
425 *
426 * @return the log File Date Format
427 */
428 public String getFilenameDateFormat()
429 {
430 return _filenameDateFormat;
431 }
432
433 /* ------------------------------------------------------------ */
434 /**
435 * Controls logging of the request dispatch time
436 *
437 * @param value true - request dispatch time will be logged
438 * false - request dispatch time will not be logged
439 */
440 public void setLogDispatch(boolean value)
441 {
442 _logDispatch = value;
443 }
444
445 /* ------------------------------------------------------------ */
446 /**
447 * Retrieve request dispatch time logging flag
448 *
449 * @return value of the flag
450 */
451 public boolean isLogDispatch()
452 {
453 return _logDispatch;
454 }
455
456 /* ------------------------------------------------------------ */
457 /**
458 * Writes the request and response information to the output stream.
459 *
460 * @see org.eclipse.jetty.server.RequestLog#log(org.eclipse.jetty.server.Request, org.eclipse.jetty.server.Response)
461 */
462 public void log(Request request, Response response)
463 {
464 try
465 {
466 if (_ignorePathMap != null && _ignorePathMap.getMatch(request.getRequestURI()) != null)
467 return;
468
469 if (_fileOut == null)
470 return;
471
472 StringBuilder buf= _buffers.get();
473 buf.setLength(0);
474
475 if (_logServer)
476 {
477 buf.append(request.getServerName());
478 buf.append(' ');
479 }
480
481 String addr = null;
482 if (_preferProxiedForAddress)
483 {
484 addr = request.getHeader(HttpHeaders.X_FORWARDED_FOR);
485 }
486
487 if (addr == null)
488 addr = request.getRemoteAddr();
489
490 buf.append(addr);
491 buf.append(" - ");
492 Authentication authentication=request.getAuthentication();
493 if (authentication instanceof Authentication.User)
494 buf.append(((Authentication.User)authentication).getUserIdentity().getUserPrincipal().getName());
495 else
496 buf.append(" - ");
497
498 buf.append(" [");
499 if (_logDateCache != null)
500 buf.append(_logDateCache.format(request.getTimeStamp()));
501 else
502 buf.append(request.getTimeStampBuffer().toString());
503
504 buf.append("] \"");
505 buf.append(request.getMethod());
506 buf.append(' ');
507 buf.append(request.getUri().toString());
508 buf.append(' ');
509 buf.append(request.getProtocol());
510 buf.append("\" ");
511 if (request.getAsyncContinuation().isInitial())
512 {
513 int status = response.getStatus();
514 if (status <= 0)
515 status = 404;
516 buf.append((char)('0' + ((status / 100) % 10)));
517 buf.append((char)('0' + ((status / 10) % 10)));
518 buf.append((char)('0' + (status % 10)));
519 }
520 else
521 buf.append("Async");
522
523 long responseLength = response.getContentCount();
524 if (responseLength >= 0)
525 {
526 buf.append(' ');
527 if (responseLength > 99999)
528 buf.append(responseLength);
529 else
530 {
531 if (responseLength > 9999)
532 buf.append((char)('0' + ((responseLength / 10000) % 10)));
533 if (responseLength > 999)
534 buf.append((char)('0' + ((responseLength / 1000) % 10)));
535 if (responseLength > 99)
536 buf.append((char)('0' + ((responseLength / 100) % 10)));
537 if (responseLength > 9)
538 buf.append((char)('0' + ((responseLength / 10) % 10)));
539 buf.append((char)('0' + (responseLength) % 10));
540 }
541 buf.append(' ');
542 }
543 else
544 buf.append(" - ");
545
546
547 if (_extended)
548 logExtended(request, response, buf);
549
550 if (_logCookies)
551 {
552 Cookie[] cookies = request.getCookies();
553 if (cookies == null || cookies.length == 0)
554 buf.append(" -");
555 else
556 {
557 buf.append(" \"");
558 for (int i = 0; i < cookies.length; i++)
559 {
560 if (i != 0)
561 buf.append(';');
562 buf.append(cookies[i].getName());
563 buf.append('=');
564 buf.append(cookies[i].getValue());
565 }
566 buf.append('\"');
567 }
568 }
569
570 if (_logDispatch || _logLatency)
571 {
572 long now = System.currentTimeMillis();
573
574 if (_logDispatch)
575 {
576 long d = request.getDispatchTime();
577 buf.append(' ');
578 buf.append(now - (d==0 ? request.getTimeStamp():d));
579 }
580
581 if (_logLatency)
582 {
583 buf.append(' ');
584 buf.append(now - request.getTimeStamp());
585 }
586 }
587
588 buf.append(StringUtil.__LINE_SEPARATOR);
589
590 String log = buf.toString();
591 write(log);
592 }
593 catch (IOException e)
594 {
595 LOG.warn(e);
596 }
597 }
598
599 /* ------------------------------------------------------------ */
600 protected void write(String log) throws IOException
601 {
602 synchronized(this)
603 {
604 if (_writer==null)
605 return;
606 _writer.write(log);
607 _writer.flush();
608 }
609 }
610
611
612 /* ------------------------------------------------------------ */
613 /**
614 * Writes extended request and response information to the output stream.
615 *
616 * @param request request object
617 * @param response response object
618 * @param b StringBuilder to write to
619 * @throws IOException
620 */
621 protected void logExtended(Request request,
622 Response response,
623 StringBuilder b) throws IOException
624 {
625 String referer = request.getHeader(HttpHeaders.REFERER);
626 if (referer == null)
627 b.append("\"-\" ");
628 else
629 {
630 b.append('"');
631 b.append(referer);
632 b.append("\" ");
633 }
634
635 String agent = request.getHeader(HttpHeaders.USER_AGENT);
636 if (agent == null)
637 b.append("\"-\" ");
638 else
639 {
640 b.append('"');
641 b.append(agent);
642 b.append('"');
643 }
644 }
645
646 /* ------------------------------------------------------------ */
647 /**
648 * Set up request logging and open log file.
649 *
650 * @see org.eclipse.jetty.util.component.AbstractLifeCycle#doStart()
651 */
652 @Override
653 protected synchronized void doStart() throws Exception
654 {
655 if (_logDateFormat != null)
656 {
657 _logDateCache = new DateCache(_logDateFormat,_logLocale);
658 _logDateCache.setTimeZoneID(_logTimeZone);
659 }
660
661 if (_filename != null)
662 {
663 _fileOut = new RolloverFileOutputStream(_filename,_append,_retainDays,TimeZone.getTimeZone(_logTimeZone),_filenameDateFormat,null);
664 _closeOut = true;
665 LOG.info("Opened " + getDatedFilename());
666 }
667 else
668 _fileOut = System.err;
669
670 _out = _fileOut;
671
672 if (_ignorePaths != null && _ignorePaths.length > 0)
673 {
674 _ignorePathMap = new PathMap();
675 for (int i = 0; i < _ignorePaths.length; i++)
676 _ignorePathMap.put(_ignorePaths[i],_ignorePaths[i]);
677 }
678 else
679 _ignorePathMap = null;
680
681 synchronized(this)
682 {
683 _writer = new OutputStreamWriter(_out);
684 }
685 super.doStart();
686 }
687
688 /* ------------------------------------------------------------ */
689 /**
690 * Close the log file and perform cleanup.
691 *
692 * @see org.eclipse.jetty.util.component.AbstractLifeCycle#doStop()
693 */
694 @Override
695 protected void doStop() throws Exception
696 {
697 synchronized (this)
698 {
699 super.doStop();
700 try
701 {
702 if (_writer != null)
703 _writer.flush();
704 }
705 catch (IOException e)
706 {
707 LOG.ignore(e);
708 }
709 if (_out != null && _closeOut)
710 try
711 {
712 _out.close();
713 }
714 catch (IOException e)
715 {
716 LOG.ignore(e);
717 }
718
719 _out = null;
720 _fileOut = null;
721 _closeOut = false;
722 _logDateCache = null;
723 _writer = null;
724 }
725 }
726 }