really fixed the redundant logging issue this time.

[sfa.git] / sfa / util / sfalogging.py

diff --git a/sfa/util/sfalogging.py b/sfa/util/sfalogging.py
index 8f04a75..f812517 100755 (executable)
--- a/sfa/util/sfalogging.py
+++ b/sfa/util/sfalogging.py
@@ -1,54 +1,74 @@
 #!/usr/bin/python
 
-import os
+import os, sys
 import traceback
 import logging, logging.handlers
 
+CRITICAL=logging.CRITICAL
+ERROR=logging.ERROR
+WARNING=logging.WARNING
+INFO=logging.INFO
+DEBUG=logging.DEBUG
+
 # a logger that can handle tracebacks 
 class _SfaLogger:
     def __init__ (self,logfile=None,loggername=None,level=logging.INFO):
         # default is to locate loggername from the logfile if avail.
         if not logfile:
-            loggername='console'
-            handler=logging.StreamHandler()
-        else:
-            if not loggername:
-                loggername=os.path.basename(logfile)
-            try:
-                handler=logging.handlers.RotatingFileHandler(logfile,maxBytes=1000000, backupCount=5) 
-            except IOError:
-                # This is usually a permissions error becaue the file is
-                # owned by root, but httpd is trying to access it.
-                tmplogfile=os.getenv("TMPDIR", "/tmp") + os.path.sep + os.path.basename(logfile)
-                handler=logging.handlers.RotatingFileHandler(tmplogfile,maxBytes=1000000, backupCount=5) 
+            #loggername='console'
+            #handler=logging.StreamHandler()
+            #handler.setFormatter(logging.Formatter("%(levelname)s %(message)s"))
+            logfile = "/var/log/sfa.log"
 
-        self.logger=logging.getLogger(loggername)
+        if not loggername:
+            loggername=os.path.basename(logfile)
+        try:
+            handler=logging.handlers.RotatingFileHandler(logfile,maxBytes=1000000, backupCount=5) 
+        except IOError:
+            # This is usually a permissions error becaue the file is
+            # owned by root, but httpd is trying to access it.
+            tmplogfile=os.getenv("TMPDIR", "/tmp") + os.path.sep + os.path.basename(logfile)
+            handler=logging.handlers.RotatingFileHandler(tmplogfile,maxBytes=1000000, backupCount=5) 
         handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+        self.logger=logging.getLogger(loggername)
         self.logger.setLevel(level)
         self.logger.addHandler(handler)
+        self.loggername=loggername
 
     def setLevel(self,level):
         self.logger.setLevel(level)
 
+    # shorthand to avoid having to import logging all over the place
+    def setLevelDebug(self):
+        self.logger.setLevel(logging.DEBUG)
+
+    # define a verbose option with s/t like
+    # parser.add_option("-v", "--verbose", action="count", dest="verbose", default=0)
+    # and pass the coresponding options.verbose to this method to adjust level
+    def setLevelFromOptVerbose(self,verbose):
+        if verbose==0:
+            self.logger.setLevel(logging.WARNING)
+        elif verbose==1:
+            self.logger.setLevel(logging.INFO)
+        elif verbose==2:
+            self.logger.setLevel(logging.DEBUG)
+
     ####################
-    def wrap(fun):
-        def wrapped(self,msg,*args,**kwds):
-            native=getattr(self.logger,fun.__name__)
-            return native(msg,*args,**kwds)
-        #wrapped.__doc__=native.__doc__
-        return wrapped
-
-    @wrap
-    def critical(): pass
-    @wrap
-    def error(): pass
-    @wrap
-    def warning(): pass
-    @wrap
-    def info(): pass
-    @wrap
-    def debug(): pass
-    
+    def info(self, msg):
+        self.logger.info(msg)
+
+    def debug(self, msg):
+        self.logger.debug(msg)
+        
+    def warn(self, msg):
+        self.logger.warn(msg)
+   
+    def error(self, msg):
+        self.logger.error(msg)    
+ 
+    def critical(self, msg):
+        self.logger.critical(msg)
+
     # logs an exception - use in an except statement
     def log_exc(self,message):
         self.error("%s BEG TRACEBACK"%message+"\n"+traceback.format_exc().strip("\n"))
@@ -64,9 +84,13 @@ class _SfaLogger:
         self.debug("%s BEG STACK"%message+"\n"+to_log)
         self.debug("%s END STACK"%message)
 
-sfa_logger=_SfaLogger(logfile='/var/log/sfa.log')
-sfa_import_logger=_SfaLogger(logfile='/var/log/sfa_import.log')
-console_logger=_SfaLogger()
+
+info_logger = _SfaLogger(loggername='info', level=logging.INFO)
+debug_logger = _SfaLogger(loggername='debug', level=logging.DEBUG)
+warn_logger = _SfaLogger(loggername='warning', level=logging.WARNING)
+error_logger = _SfaLogger(loggername='error', level=logging.ERROR)
+critical_logger = _SfaLogger(loggername='critical', level=logging.CRITICAL)
+logger = info_logger
 
 ########################################
 import time
@@ -85,7 +109,7 @@ def profile(logger):
             result = callable(*args, **kwds)
             end = time.time()
             args = map(str, args)
-            args += ["%s = %s" % (name, str(value)) for (name, value) in kwds.items()]
+            args += ["%s = %s" % (name, str(value)) for (name, value) in kwds.iteritems()]
             # should probably use debug, but then debug is not always enabled
             logger.info("PROFILED %s (%s): %.02f s" % (callable.__name__, ", ".join(args), end - start))
             return result
@@ -104,12 +128,13 @@ if __name__ == '__main__':
     logger.setLevel(logging.DEBUG)
     logger.debug("logger.debug again")
     
-    @profile(console_logger)
+
+    @profile(my_logger)
     def sleep(seconds = 1):
         time.sleep(seconds)
 
-    
-    console_logger.info('console.info')
+    my_logger.info('console.info')
     sleep(0.5)
-    console_logger.setLevel(logging.DEBUG)
+    my_logger.setLevel(logging.DEBUG)
     sleep(0.25)
+