service/logging/SyslogHandler.java

	SyslogHandler.java revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* ident    "%Z%%M% %I% %E% SMI" */

package com.sun.solaris.service.logging;

import java.text.*;
import java.util.*;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.LogRecord;

import com.sun.solaris.service.exception.SuccinctStackTraceFormatter;

/**
 * This handler outputs LogRecords with <code>syslog(3C)</code> to the
 * given facility with a severity translated by Level with a fixed
 * table.  Formatters are not used.
 *
 * Multiple SyslogHandlers may not be in concurrent use in one virtual
 * machine.
 */
public final class SyslogHandler extends Handler {
    /**
     * <code>syslog(3C)</code> ident string, prepended to every
     * message.
     */
    private String ident;

    /**
     * <code>syslog</code> facility to be logged to.
     */
    private Facility facility;

    /**
     * Records the instance of this singleton.
     */
    private static SyslogHandler instance = null;

    /**
     * Flag whether stack traces should be output when a record's
     * <code>thrown</code> field is set.  They will be formatted in
     * a single line by <code>SuccinctStackTraceFormatter</code>,
     * which does not include the Throwable's description, since
     * it's presumably described by the log message).  Default
     * <code>true</code>.
     */
    private static boolean useStackTraces = true;

    /**
     * Default logging option value.  Sets no options.  (Corresponds
     * to the <code>logopt</code> argument to openlog(3c).)
     */
    private static final int DEF_LOGOPT = 0;

    /**
     * Flag to set whether log records should indicate the record's
     * logger.  (default false)
     */
    private boolean useLoggerName = false;

    /**
     * Flag to set whether log records should indicate the last
     * component of the record's logger name, if useLoggerName isn't
     * set.  (default true)
     */
    private boolean useShortLoggerName = true;

    static {
        System.loadLibrary("jsyslog");
    }

    private SyslogHandler(String ident, Facility facility)
    {
        if (ident == null || facility == null)
            throw new IllegalArgumentException();

        this.ident = ident;
        this.facility = facility;

        openlog(ident, DEF_LOGOPT, facility.getNative());
        instance = this;
    }

    /**
     * Return this virtual machine's instance of SyslogHandler,
     * creating one which logs with the given identity to the given
     * facility if necessary, unless an instance with a different
     * identity or facility is already open, in which case an
     * IllegalArgumentException is thrown.
     *
     * @throws IllegalArgumentException if the requested identity or
     * facility differs from a previously-created instance.
     */
    public static SyslogHandler getInstance(String ident,
       Facility facility)
    {
        if (instance != null) {
            if (!instance.ident.equals(ident) ||
                !instance.facility.equals(facility))
                throw new IllegalArgumentException();
            else
                return (instance);
        } else
            return (instance = new SyslogHandler(ident, facility));
    }

    public void finalize()
    {
        try {
            close();
        } catch (Exception e) {
            // superclass-defined exceptions do not apply
        }
    }

    public String toString()
    {
        return ("SyslogHandler(" + ident + ", " + facility.toString() +
            ")");
    }

    /**
     * Calls <code>syslog(3C)</code>.
     */
    private static native void syslog(int severity, String message);

    /**
     * Calls <code>openlog(3C)</code>.
     */
    private static native void openlog(String ident, int logopt,
        int facility);

    /**
     * Calls <code>closelog(3C)</code>.
     */
    private static native void closelog();

    /**
     * Publishes the given record with its associated Severity (or
     * infers its severity with Severity.severityForLevel(), if
     * another type of Level is used), if the result is non-null.
     */
    public void publish(LogRecord record)
    {
        Severity severity;

        if (record.getLevel() instanceof Severity)
            severity = (Severity)record.getLevel();
        else
            severity = Severity.severityForLevel(record
                .getLevel());

        if (getLevel().intValue() > severity.intValue())
            return;

        /*
         * If the severity is null, the message isn't meant to
         * be sent to syslog.
         */
        if (severity == null)
            return;

        StringBuffer message = new StringBuffer();
        String loggerName = record.getLoggerName();
        if (useLoggerName) {
            if (loggerName != null) {
                message.append("(");
                message.append(record.getLoggerName());
                message.append(") ");
            }
        } else if (useShortLoggerName) {
            if (loggerName != null) {
                message.append("(");
                int lastDot = loggerName.lastIndexOf('.');
                if (lastDot >= 0)
                    loggerName = loggerName.substring(
                        lastDot + 1);
                message.append(loggerName);
                message.append(") ");
            }
        }

        message.append(record.getMessage());

        /*
         * If the Severity is null, it's not meant to be logged
         * via syslog.
         */
        if (record.getThrown() != null && useStackTraces == true) {
            /*
             * Format the stack trace as one line and tack
             * it onto the message.
             */
            message.append(" ");
            message.append(SuccinctStackTraceFormatter
                .formatWithDescription(record.getThrown(),
                "with tracing information: ").toString());
        }
        syslog(severity.getNative(), message.toString());
    }

    public void flush()
    {
    }

    public void close() throws SecurityException
    {
        if (instance != null) {
            closelog();
            instance = null;
        }
    }

    /**
     * Formatters may not be used with SyslogHandler.
     *
     * @throws IllegalArgumentException if the use of one is
     * attempted.
     */
    public void setFormatter(Formatter formatter)
    {
        throw new IllegalArgumentException();
    }

    /**
     * Returns the <code>syslog(3C)</code> ident string, which is
     * prepended to every message.
     */
    public String getIdent()
    {
        return (ident);
    }

    /**
     * Returns the <code>syslog</code> facility to be logged to.
     */
    public Facility getFacility()
    {
        return (facility);
    }

}