001 /***************************************************************************** 002 * Copyright (C) PicoContainer Organization. All rights reserved. * 003 * ------------------------------------------------------------------------- * 004 * The software in this package is published under the terms of the BSD * 005 * style license a copy of which has been included with this distribution in * 006 * the LICENSE.txt file. * 007 * * 008 * Original code by Mauro Talevi * 009 *****************************************************************************/ 010 011 package org.picocontainer.gems.monitors; 012 013 import java.io.Serializable; 014 import java.lang.reflect.Constructor; 015 import java.lang.reflect.Method; 016 import java.lang.reflect.Member; 017 018 import org.apache.commons.logging.Log; 019 import org.apache.commons.logging.LogFactory; 020 import org.picocontainer.ComponentMonitor; 021 import org.picocontainer.monitors.AbstractComponentMonitor; 022 import org.picocontainer.monitors.DefaultComponentMonitor; 023 024 025 /** 026 * A {@link ComponentMonitor} which writes to a Commons Logging {@link Log Log} instance. 027 * The Log instance can either be injected or, if not set, the {@link LogFactory LogFactory} 028 * will be used to retrieve it at every invocation of the monitor. 029 * 030 * @author Paul Hammant 031 * @author Mauro Talevi 032 * @version $Revision: $ 033 */ 034 public class CommonsLoggingComponentMonitor extends AbstractComponentMonitor implements Serializable { 035 036 private Log log; 037 private final ComponentMonitor delegate; 038 039 /** 040 * Creates a CommonsLoggingComponentMonitor with no Log instance set. 041 * The {@link LogFactory LogFactory} will be used to retrieve the Log instance 042 * at every invocation of the monitor. 043 */ 044 public CommonsLoggingComponentMonitor() { 045 delegate = new DefaultComponentMonitor(); 046 } 047 048 /** 049 * Creates a CommonsLoggingComponentMonitor with a given Log instance class. 050 * The class name is used to retrieve the Log instance. 051 * 052 * @param logClass the class of the Log 053 */ 054 public CommonsLoggingComponentMonitor(Class logClass) { 055 this(logClass.getName()); 056 } 057 058 /** 059 * Creates a CommonsLoggingComponentMonitor with a given Log instance name. It uses the 060 * {@link LogFactory LogFactory} to create the Log instance. 061 * 062 * @param logName the name of the Log 063 */ 064 public CommonsLoggingComponentMonitor(String logName) { 065 this(LogFactory.getLog(logName)); 066 } 067 068 /** 069 * Creates a CommonsLoggingComponentMonitor with a given Log instance 070 * 071 * @param log the Log to write to 072 */ 073 public CommonsLoggingComponentMonitor(Log log) { 074 this(); 075 this.log = log; 076 } 077 078 /** 079 * Creates a CommonsLoggingComponentMonitor with a given Log instance class. 080 * The class name is used to retrieve the Log instance. 081 * 082 * @param logClass the class of the Log 083 */ 084 public CommonsLoggingComponentMonitor(Class logClass, ComponentMonitor delegate) { 085 this(logClass.getName(), delegate); 086 } 087 088 /** 089 * Creates a CommonsLoggingComponentMonitor with a given Log instance name. It uses the 090 * {@link LogFactory LogFactory} to create the Log instance. 091 * 092 * @param logName the name of the Log 093 */ 094 public CommonsLoggingComponentMonitor(String logName, ComponentMonitor delegate) { 095 this(LogFactory.getLog(logName), delegate); 096 } 097 098 /** 099 * Creates a CommonsLoggingComponentMonitor with a given Log instance 100 * 101 * @param log the Log to write to 102 */ 103 public CommonsLoggingComponentMonitor(Log log, ComponentMonitor delegate) { 104 this.log = log; 105 this.delegate = delegate; 106 } 107 108 109 public void instantiating(Constructor constructor) { 110 Log log = getLog(constructor); 111 if (log.isDebugEnabled()) { 112 log.debug(format(INSTANTIATING, new Object[]{toString(constructor)})); 113 } 114 delegate.instantiating(constructor); 115 } 116 117 public void instantiated(Constructor constructor, long duration) { 118 Log log = getLog(constructor); 119 if (log.isDebugEnabled()) { 120 log.debug(format(INSTANTIATED, new Object[]{toString(constructor), new Long(duration)})); 121 } 122 delegate.instantiated(constructor, duration); 123 } 124 125 public void instantiated(Constructor constructor, Object instantiated, Object[] parameters, long duration) { 126 Log log = getLog(constructor); 127 if (log.isDebugEnabled()) { 128 log.debug(format(INSTANTIATED2, new Object[]{toString(constructor), new Long(duration), instantiated.getClass().getName(), toString(parameters)})); 129 } 130 delegate.instantiated(constructor, instantiated, parameters, duration); 131 } 132 133 public void instantiationFailed(Constructor constructor, Exception cause) { 134 Log log = getLog(constructor); 135 if (log.isWarnEnabled()) { 136 log.warn(format(INSTANTIATION_FAILED, new Object[]{toString(constructor), cause.getMessage()}), cause); 137 } 138 delegate.instantiationFailed(constructor, cause); 139 } 140 141 public void invoking(Method method, Object instance) { 142 Log log = getLog(method); 143 if (log.isDebugEnabled()) { 144 log.debug(format(INVOKING, new Object[]{toString(method), instance})); 145 } 146 delegate.invoking(method, instance); 147 } 148 149 public void invoked(Method method, Object instance, long duration) { 150 Log log = getLog(method); 151 if (log.isDebugEnabled()) { 152 log.debug(format(INVOKED, new Object[]{toString(method), instance, new Long(duration)})); 153 } 154 delegate.invoked(method, instance, duration); 155 } 156 157 public void invocationFailed(Method method, Object instance, Exception cause) { 158 Log log = getLog(method); 159 if (log.isWarnEnabled()) { 160 log.warn(format(INVOCATION_FAILED, new Object[]{toString(method), instance, cause.getMessage()}), cause); 161 } 162 delegate.invocationFailed(method, instance, cause); 163 } 164 165 public void lifecycleInvocationFailed(Method method, Object instance, RuntimeException cause) { 166 Log log = getLog(method); 167 if (log.isWarnEnabled()) { 168 log.warn(format(LIFECYCLE_INVOCATION_FAILED, new Object[]{toString(method), instance, cause.getMessage()}), cause); 169 } 170 delegate.lifecycleInvocationFailed(method, instance, cause); 171 } 172 173 protected Log getLog(Member member) { 174 if ( log != null ){ 175 return log; 176 } 177 return LogFactory.getLog(member.getDeclaringClass()); 178 } 179 180 }