<document>
<localtoc/>

You can take advantage of the JDK's logging facility to add logging to your application. Choosing a good logging name and levels are important for troubleshooting and debugging your code. Logging to much can be almost as confusing as logging too little.

The logging name should be the full class name of the class you're instrumenting. Although other schemes are possible, the class name is more maintainable.

The logging level should be consistent across your application. For Resin, we use the following level conventions:

import java.util.logging.Logger; import java.util.logging.Level; public class Foo { private static final Logger log = Logger.getLogger(Foo.class.getName()); ... void doFoo(String bar) { // check for log level if your logging call does anything more // than pass parameters if (log.isLoggable(Level.FINER)) log.finer(this + "doFoo(" + bar + ")"); ... log.info(...); try { ... } catch (ExpectedException ex) { log.log(Level.FINEST, "expected exception", ex); } } ... }

The JDK logging api uses a hierarchical naming scheme. Typically the name is aligned with a java class name. When you specify a name, all logging requests that use a name that starts with the name you have specified are matched. For example: `<logger name="example.hogwarts" ...>` matches a logging request for both "example.hogwarts.System" and "example.hogwarts.gryffindor.System"

Resin's logging is based on Resin's source class names. The following are useful logs.

name Meaning
"" Debug everything
com.caucho.amber Amber (JPA) handling
com.caucho.ejb EJB handling
com.caucho.jsp Debug jsp
com.caucho.java Java compilation
com.caucho.server.port TCP port debugging and threading
com.caucho.server.port.AcceptPool port thread creation
com.caucho.server.http HTTP-related debugging
com.caucho.server.webapp web-app related debugging
com.caucho.server.cache Cache related debugging
com.caucho.sql Database pooling
com.caucho.transaction Transaction handling

The level for log tags matches the levels in the JDK .

Name API Suggested Use
off turn off logging
severe log.severe("...") a major failure which prevents normal program execution, e.g. a web-app failing to start or a server restart
warning log.warning("...") a serious issue, likely causing incorrect behavior, like a 500 response code to a browser
info log.info("...") major lifecycle events, like a web-app starting
config log.config("...") detailed configuration logging
fine log.fine("...") debugging at an administrator level, i.e. for someone not familiar with the source code being debugged
finer log.finer("...") detailed debugging for a developer of the code being debugged
finest log.finest("...") events not normally debugged, e.g. expected exceptions logged to avoid completely swallowing, or Hessian or XML protocol parsing
all all messages should be logged
<parents>resin, server, host-default, host, web-app-default, web-app</parents>

Configure a log handler for the JDK java.util.logging.* API. java.util.logging has two steps: configure a set of log handlers, and configure the levels for each logger. The <log-handler> creates a destination for logs, sets a minimum logging level for the handler, and attaches the handler to a logging name.

In addition to configuring custom handlers, <log-handler> has the most common configuration build-in: logging to a rotating file. Most of the configuration attributes are used for the rotating file and are shared with the other logging configuration.

Attribute Description Default
archive-format the format for the archive filename when a rollover occurs, see Rollovers. see below
class configures a custom Handler class
formatter Configures a custom java.util.logging.Formatter to format the output.
init IoC-style initialization configuration for the formatter.
level The log level for the handler. Typically, the handler's level will be finer than the logger's level info
mbean-name an mbean name, see MBean control. no mbean name, no mbean registration
name A hierarchical name, typically aligned with the Java packaging names. The handler will be registered with the Logger with the matching name. match all names
path Output path for the log messages, see "Log Paths" required
path-format Selects a format for generating path names. The syntax is the same as for archive-format optional
timestamp a timestamp format string to use at the beginning of each log line. "[%Y/%m/%d %H:%M:%S.%s] "
rollover-count maximum number of rollover files before the oldest ones get overwritten. See Rollovers. none
rollover-period how often to rollover the log. Specify in days (15D), weeks (2W), months (1M), or hours (1h). See Rollovers. none
rollover-size maximum size of the file before a rollover occurs, in bytes (50000), kb (128kb), or megabytes (10mb). See Rollovers. 1mb
uri configures a symbolic alias for the handler's class. The handler implementer will register the schema
element log-handler { archive-format? & class? & filter? & format? & formatter? & init? & level? & mbean-name? & name & path? & path-format? & rollover-count? & rollover-period? & rollover-size? & timestamp? & uri? & use-parent-handlers? }

The following example sends warning messages to a JMS queue. The `uri="jms:"` is an alias for `com.caucho.log.handler.JmsHandler`. The `uri="timestamp:"` is a formatter alias for `com.caucho.log.formatter.TimestampFormatter`

<web-app xmlns="http://caucho.com/ns/resin"> <jms-queue name="myQueue" uri="memory:"/> <log-handler name="qa.test" level="warning" uri="jms:"> <init target="${myQueue}"/> <formatter uri="timestamp:"/> </log-handler> </web-app>

The following example is a standard log handler writing to a rollover file. Because the handler's level is "all", the <logger> configuration will set the actual logging level.

<web-app xmlns="http://caucho.com/ns/resin"> <jms-queue name="myQueue" uri="memory:"/> <log-handler name="" level="all" timestamp="[%Y/%m/%d %H:%M:%S.%s] {%{thread}} "/> <logger name="com.caucho" level="info"/> </web-app> <parents>resin, server, host-default, host, web-app-default, web-app</parents>

Configure the amount and destination of debug logging for the JDK java.util.logging.* API.

Attribute Description Default
name A hierarchical name, typically aligned with the Java packaging names match all names
level The log level info
path Output path for the log messages, see "Log Paths" required
path-format Selects a format for generating path names. The syntax is the same as for archive-format optional
timestamp a timestamp format string to use at the beginning of each log line. "[%Y/%m/%d %H:%M:%S.%s] "
format a format string to control the output of each log message. Since Resin 3.0.5. ${log.message}
rollover-count maximum number of rollover files before the oldest ones get overwritten. See Rollovers. none
rollover-period how often to rollover the log. Specify in days (15D), weeks (2W), months (1M), or hours (1h). See Rollovers. none
rollover-size maximum size of the file before a rollover occurs, in bytes (50000), kb (128kb), or megabytes (10mb). See Rollovers. 1mb
archive-format the format for the archive filename when a rollover occurs, see Rollovers. see below
mbean-name an mbean name, see MBean control. no mbean name, no mbean registration
handler add a custom Handler, the name of a class that extends
formatter set a custom Formatter, the name of a class that extends none, or if format is used.

The default archive format is

path + ".%Y%m%d" if rollover-period >= 1 day. path + ".%Y%m%d.%H" if rollover-period < 1 day.

For example, to log everything to standard error use:

<resin xmlns="http://caucho.com/ns/resin"> <log name='' level='all' path='stderr:' timestamp="[%H:%M:%S.%s]"/> ... </resin>

A useful technique is to enable full debug logging to track down a problem:

<resin> ... <log name='' level='finer' path='log/debug.log' timestamp="[%H:%M:%S.%s]" rollover-period='1h' rollover-count='1'/> ... </resin>

More examples of debug logging are in the Troubleshooting section.

The class that corresponds to <log> is .

The format for log tags is used to specify a format string for each log message. `format` recognizes EL-expressions. The EL variable log is a object.

<log name='' level='all' path='stderr:' timestamp="[%H:%M:%S.%s]" format=" ${log.level} ${log.loggerName} ${log.message}"/>
AccessorValue
${log.level}The level of the log record
${log.name}The source loggers name
${log.shortName}A shorter version of the source loggers name, "Foo" instead of "com.hogwarts.Foo"
${log.message}The message, with no formatting or localization
${log.millis}event time in milliseconds since 1970
${log.sourceClassName}Get the name of the class that issued the logging request (may not be available at runtime)
${log.sourceMethodName}Get the name of the method that issued the logging request (may not be available at runtime)
${log.threadID}Get an int identifier of the thread where the logging request originated
${log.thrown}Get any associated with the logging request

You can also use the Environment EL variables in your format string:

<host ...> <web-app> <log name='' level='all' path='log/debug.log' timestamp="[%H:%M:%S.%s]" format=" [${'${'}app.contextPath}] ${'${'}log.message}"/> ... </web-app> ... </host> <results> [14:55:10.189] [/foo] `null' returning JNDI java: model for EnvironmentClassLoader[web-app:http://localhost:8080/foo] [14:55:10.189] [/foo] JNDI lookup `java:comp/env/caucho/auth' exception javax.naming.NameNotFoundException: java:comp/env/caucho/auth [14:55:10.199] [/foo] Application[http://localhost:8080/foo] starting </results>

The fmt.sprintf() function can space pad the values and make the results look a little nicer:

<log name='' level='all' path='stderr:' timestamp="[%H:%M:%S.%s]" format=" ${fmt.sprintf('%-7s %45s %s',log.level,log.loggerName,log.message)}"/> <results> [14:28:08.137] INFO com.caucho.vfs.QJniServerSocket Loaded Socket JNI library. [14:28:08.137] INFO com.caucho.server.port.Port http listening to *:8080 [14:28:08.137] INFO com.caucho.server.resin.ServletServer ServletServer[] starting [14:28:08.307] INFO com.caucho.server.port.Port hmux listening to localhost:6802 [14:28:08.437] INFO com.caucho.server.host.Host Host[] starting </results>

fmt.sprintf() and fmt.timestamp() can be used to produce CSV files:

<log name='' level='all' path='log/debug.csv' timestamp="" format="${fmt.sprintf('%vs,%d,%d,%vs,%vs',fmt.timestamp('%Y-%m-%d %H:%M:%S.%s'), log.threadID, log.level.intLevel(), log.loggerName, log.message)}"/> <results> "2003-11-17 14:46:14.529",10,800,"com.caucho.vfs.QJniServerSocket", "Loaded Socket JNI library." "2003-11-17 14:46:14.549",10,800,"com.caucho.server.port.Port", "http listening to *:8080" "2003-11-17 14:46:14.549",10,800,"com.caucho.server.resin.ServletServer", "ServletServer[] starting" "2003-11-17 14:46:14.719",10,800,"com.caucho.server.port.Port", "hmux listening to localhost:6802" "2003-11-17 14:46:14.850",10,800,"com.caucho.server.host.Host", "Host[] starting" "2003-11-17 14:46:15.100",10,800,"com.caucho.server.webapp.Application", "Application[http://localhost:8080/freelistbm] starting" </results>

Resin provides a number of predefined custom log handlers for common logging patterns, including sending messages to JMS, HMTP, and the syslog service. Creating your own custom handler is also straightforward.

The event handler publishes a `LogEvent` to the WebBeans event system. Any WebBeans component with an `@Observes` method for `LogEvent` will receive the notifications. The log handler classname is `com.caucho.log.handler.EventHandler` and the shortcut is uri="event:".

<web-app xmlns="http://caucho.com/ns/resin"> <log-handler name="com.foo" level="warning" uri="event:"/> </web-app>

The HMTP handler publishes the log message to a HMTP agent. The agent can be a custom HMTP service to process log messages. The `HmtpHandler` needs a JID (Jabber id) as the address of the target service.

<web-app xmlns="http://caucho.com/ns/resin"> <log-handler name="com.foo" level="warning" uri="hmtp:"> <init> <to>test@localhost</to> </init> </log-handler> </web-app>

The JMS handler publishes the log message to a JMS queue.

<web-app xmlns="http://caucho.com/ns/resin"> <jms-queue name="myQueue" uri="memory:"/> <log-handler name="com.foo" level="warning" uri="jms:"> <init> <target>${myQueue}</target> </init> </log-handler> </web-app>

On Unix systems, the SyslogHandler lets you log messages to syslog.

<resin xmlns="http://caucho.com/ns/resin"> <log-handler name="" level="warning" uri="syslog:"> <init> <facility>daemon</facility> <severity>notice</severity> </init> </log-handler>

The possible values for facility are user, mail, daemon, auth, lpr, news, uucp, cron, authpriv, ftp, local0, local1, local2, local3, local4, local5, local6, local7. The default is daemon.

The possible values for severity are emerg, alert, crit, err, warning, notice, info, debug. The default is info.

See also ``man 3 syslog`' and ``man syslog.conf`'.

<web-app xmlns="http://caucho.com/ns/resin"> <log-handler name="" level="warning" class="demo.MyHandler"/> </web-app> package demo; import java.util.logging.*; public class MyHandler extends Handler { @Override public void publish(LogRecord record) { System.out.println(getFormatter().format(record)); } @Override public void flush(); { } @Override public void close(); { } }

Sites may wish to change the formatting of log messages to gather information more appropriate for the site. The formatter can be custom-configured just like the handlers.

<web-app xmlns="http://caucho.com/ns/resin"> <log-handler name="com.foo" level="warning" path="WEB-INF/log.log"> <formatter class="qa.MyFormatter"/> </log-handler> </web-app> package demo; import java.util.logging.*; public class MyFormatter extends Formatter { @Override public String format(LogRecord record) { return "[" + record.getLevel() + "] " + record.getMessage(); } } <parents>resin, server, host-default, web-app-default, web-app</parents> <default>use the JDK's destination for System.out</default>

Configure the destination for System.out.

Usage of the stdout-log overrides a previous usage. For example, specifying stdout-log as a child of a causes a redirection of System.out for that web application only, and will override the System.out location in the enclosing .

<warn>The path must not be the same as the path specified on the command line with `-stdout`. If it is, there will be conflicts with which process owns the file.</warn>
archive-format the format for the archive filename when a rollover occurs, see Rollovers. see below
path Output path for the stream, see "Log Paths". required
path-format Selects a format for generating path names. The syntax is the same as for archive-format optional
rollover-count maximum number of rollover files before the oldest ones get overwritten. See Rollovers. none
rollover-period how often to rollover the log. Specify in days (15D), weeks (2W), months (1M), or hours (1h). See Rollovers. none
rollover-size maximum size of the file before a rollover occurs, in bytes (50000), kb (128kb), or megabytes (10mb). See Rollovers. 1mb
timestamp a timestamp format string to use at the beginning of each log line. no timestamp

The default archive format is

      path + ".%Y%m%d" or
      path + ".%Y%m%d.%H" if rollover-period < 1 day.

The following example configures System.out for a . Unless a web-app overrides with it's own `stdout-log`, all web-apps in the host will write to the same output file.

<example> ... <host id='foo.com'> <stdout-log path='/var/log/foo/stdout.log' rollover-period='1W'/> ... </host> ... <parents>resin, server, host-default, web-app-default, web-app</parents> <default>use the JDK's destination for System.err</default>

Configure the destination for System.err.

Usage of the stderr-log overrides a previous usage. For example, specifying stderr-log as a child of a causes a redirection of System.err for that web application only, and will override the System.err location in the enclosing .

<warn>The path must not be the same as the path specified on the command line with `-stderr`. If it is, there will be conflicts with which process owns the file.</warn>
path Output path for the stream, see "Log Paths". required
path-format Selects a format for generating path names. The syntax is the same as for archive-format optional
timestamp a timestamp format string to use at the beginning of each log line. no timestamp
rollover-count maximum number of rollover files before the oldest ones get overwritten. See Rollovers. none
rollover-period how often to rollover the log. Specify in days (15D), weeks (2W), months (1M), or hours (1h). See Rollovers. none
rollover-size maximum size of the file before a rollover occurs, in bytes (50000), kb (128kb), or megabytes (10mb). See Rollovers. 1mb
archive-format the format for the archive filename when a rollover occurs, see Rollovers. see below

The default archive format is

      path + ".%Y%m%d" or
      path + ".%Y%m%d.%H" if rollover-period < 1 day.

The following example configures System.err for a . Unless a web-app overrides with it's own `stderr-log`, all web-apps in the host will write to the same output file.

<example> ... <host id='foo.com'> <stderr-log path='/var/log/foo/stderr.log' rollover-period='1W'/> ... </host> ... <parents>server, host-default, host, web-app-default, web-app</parents>

Specify the access log file.

As a child of , overrides the definition in the that the web-app is deployed in. As a child of , overrides the definition in the that the host is in.

path Output path for the log entries, see "Log Paths". required
path-format Selects a format for generating path names. The syntax is the same as for archive-format optional
format Access log format. see below
rollover-count maximum number of rollover files before the oldest ones get overwritten. See Rollovers. none
rollover-period how often to rollover the log. Specify in days (15D), weeks (2W), months (1M), or hours (1h). See Rollovers. none
rollover-size maximum size of the file before a rollover occurs, in bytes (50000), kb (128kb), or megabytes (10mb). See Rollovers. 1mb
archive-format the format for the archive filename when a rollover occurs, see Rollovers. see below
auto-flush true to flush the memory buffer with each request false
resin:type a class extending for custom logging com.caucho.server.log.AccessLog
initbean-style initialization for the custom classn/a

The default archive format is

      path + ".%Y%m%d" or
      path + ".%Y%m%d.%H" if rollover-period < 1 day.

<example> ... <host id=''> <access-log path='log/access.log'> <rollover-period>2W</rollover-period> </access-log> ... </host> ...

The access log formatting variables follow the Apache variables:

<deftable>
%b result content length
%D time taken to complete the request in microseconds (since 3.0.16)
%h remote IP addr
%{xxx}i request header xxx
%{xxx}o response header xxx
%{xxx}c cookie value xxx
%n request attribute
%r request URL
%s status code
%{xxx}t request date with optional time format string.
%T time taken to complete the request in seconds
%u remote user
%U request URI

The default format is:

<def> "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\""

resin:type allows for custom logging. Applications can extend a custom class from . Bean-style initialization can be used to set bean parameters in the custom class.

<example> ... <host id='foo.com'> <access-log resin:type='test.MyLog'> path='$server-root/foo/error.log' rollover-period='1W'> <init> <foo>bar</foo> </init> </access-log> ... </host> ...

path is used to configure a destination for the messages. Typically, `access-log`, `stdout-log`, and `stderr-log` are configured to go to files, and `log` is configured to go to a file or to stderr or stdout so that they show up on the console screen.

<deftable>
PathResult
filesystem pathoutput log entries to a file
stdout:output log entries to stdout
stderr:output log entries to stderr
<log name="" level="all" path="stdout:"/>

You can use the Environment EL variables as part of your filesystem path:

<log name="" level="all" path="log/debug-${server.id}.log" rollover-period="1h" rollover-count="1"/>

Log rollovers are a way to stop your log files from getting too large. When a rollover is triggered, the existing log file is renamed and a new file is started.

A size based rollover is triggered when the size of the file reaches a certain amount. The default Resin behaviour for log's is to rollover when the file size reaches 1mb.

`rollover-size` is used to specify the maximum size, and can be in bytes (50000), kilobytes (128kb), or megabytes (10mb). A value of `-1` disables size based rollovers.

A time based rollover is triggered when a certain period of time has passed since the last rollover. The default Resin behaviour is to perform no time based rollover, unless rollover-size has been disabled with a value of -1 in which case the default time period is 1 month.

`rollover-period` is used to specify the time period, and can be in days (15D), weeks (2W), months (1M), or hours (1h).

When a rollover is triggered, the log file is renamed (archived) and a new log file is started.

`archive-format` is used to specify the name of the archive file. It can contain regular characters, EL Environment variables, and % codes that capture the current date and time. The % codes are the same as the ones used for `timestamp` (see Timestamp format string).

The default behaviour depends on the value of rollover-period. If rollover-period is greater than one day, or is not being used because rollover-size has been specified, the archive filename is the original path with `.%Y%m%d` appended. If rollover-period is less than one day, the archive filename is the original path with `.%Y%m%d.%H` appended.

To completely disable rollovers, set the `rollover-size` to such a high number that it will never occur:

<stdout-log path="log//stdout.log" rollover-size="1024mb"/>

Rollover log files can be compressed with gzip or zip. The extension of the archive-format determines the compression.

<example> <log name="" level="warning" path='log/error.log' archive-format="%Y-%m-%d.error.log.gz" rollover-period="1D"/> <access-log path="log/access.log" archive-format="access-%Y%m%d.log.gz" rollover-period="1D"/>

The timestamp for log tags is a format string which can contain percent codes which are substituted with time and date values.

<deftable>
CodeMeaning
%aday of week (short)
%Aday of week (verbose)
%bday of month (short)
%Bday of month (verbose)
%cJava locale date
%dday of month (two-digit)
%H24-hour (two-digit)
%I12-hour (two-digit)
%jday of year (three-digit)
%mmonth (two-digit)
%Mminutes
%pam/pm
%Sseconds
%smilliseconds
%Wweek in year (three-digit)
%wday of week (one-digit)
%yyear (two-digit)
%Yyear (four-digit)
%Ztime zone (name)
%ztime zone (+/-0800)
<log name='' level='all' path='stderr:' timestamp="[%H:%M:%S.%s]"/> <results> [22:50:11.648] Application[/doc] starting [22:50:11.698] http listening to *:8080 [22:50:11.828] hmux listening to *:6802 </results>
</document>