/*
 * 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);
	}

}