Docs for DAL.logger

[ Python Tutorial ] [ Python Libraries ] [ web2py epydoc ]

Description


    Instances of the Logger class represent a single logging channel. A
    "logging channel" indicates an area of an application. Exactly how an
    "area" is defined is up to the application developer. Since an
    application can have any number of areas, logging channels are identified
    by a unique string. Application areas can be nested (e.g. an area
    of "input processing" might include sub-areas "read CSV files", "read
    XLS files" and "read Gnumeric files"). To cater for this natural nesting,
    channel names are organized into a namespace hierarchy where levels are
    separated by periods, much like the Java or Python package namespace. So
    in the instance given above, channel names might be "input" for the upper
    level, and "input.csv", "input.xls" and "input.gnu" for the sub-levels.
    There is no arbitrary limit to the depth of nesting.

Attributes


DAL.logger.__class__	<type 'type'> extends (<class 'logging.Filterer'>,) belongs to class <type 'type'> Instances of the Logger class represent a single logging channel. A "logging channel" indicates an area of an application. Exactly how an "area" is defined is up to the application developer. Since an application can have any number of areas, logging channels are identified by a unique string. Application areas can be nested (e.g. an area of "input processing" might include sub-areas "read CSV files", "read XLS files" and "read Gnumeric files"). To cater for this natural nesting, channel names are organized into a namespace hierarchy where levels are separated by periods, much like the Java or Python package namespace. So in the instance given above, channel names might be "input" for the upper level, and "input.csv", "input.xls" and "input.gnu" for the sub-levels. There is no arbitrary limit to the depth of nesting.

DAL.logger.__delattr__	<type 'method-wrapper'> belongs to class <type 'method-wrapper'> x.__delattr__('name') <==> del x.name

DAL.logger.__dict__	<type 'dict'> belongs to class <type 'dict'> dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

DAL.logger.__doc__	<type 'str'> belongs to class <type 'str'> str(object='') -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.

DAL.logger.__format__	<type 'builtin_function_or_method'> belongs to class <type 'builtin_function_or_method'> default object formatter

DAL.logger.__getattribute__	<type 'method-wrapper'> belongs to class <type 'method-wrapper'> x.__getattribute__('name') <==> x.name

DAL.logger.__hash__	<type 'method-wrapper'> belongs to class <type 'method-wrapper'> x.__hash__() <==> hash(x)

DAL.logger.__init__	<type 'instancemethod'> belongs to class <type 'instancemethod'> Initialize the logger with a name and an optional level.

DAL.logger.__module__	<type 'str'> belongs to class <type 'str'> str(object='') -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.

DAL.logger.__new__	<type 'builtin_function_or_method'> belongs to class <type 'builtin_function_or_method'> T.__new__(S, ...) -> a new object with type S, a subtype of T

DAL.logger.__reduce__	<type 'builtin_function_or_method'> belongs to class <type 'builtin_function_or_method'> helper for pickle

DAL.logger.__reduce_ex__	<type 'builtin_function_or_method'> belongs to class <type 'builtin_function_or_method'> helper for pickle

DAL.logger.__repr__	<type 'method-wrapper'> belongs to class <type 'method-wrapper'> x.__repr__() <==> repr(x)

DAL.logger.__setattr__	<type 'method-wrapper'> belongs to class <type 'method-wrapper'> x.__setattr__('name', value) <==> x.name = value

DAL.logger.__sizeof__	<type 'builtin_function_or_method'> belongs to class <type 'builtin_function_or_method'> __sizeof__() -> int size of object in memory, in bytes

DAL.logger.__str__	<type 'method-wrapper'> belongs to class <type 'method-wrapper'> x.__str__() <==> str(x)

DAL.logger.__subclasshook__	<type 'builtin_function_or_method'> belongs to class <type 'builtin_function_or_method'> Abstract classes can override this to customize issubclass(). This is invoked early on by abc.ABCMeta.__subclasscheck__(). It should return True, False or NotImplemented. If it returns NotImplemented, the normal algorithm is used. Otherwise, it overrides the normal algorithm (and the outcome is cached).

DAL.logger.__weakref__	<type 'NoneType'> belongs to class <type 'NoneType'>

DAL.logger._log	<type 'instancemethod'> belongs to class <type 'instancemethod'> Low-level logging routine which creates a LogRecord and then calls all the handlers of this logger to handle the record.

DAL.logger.addFilter	<type 'instancemethod'> belongs to class <type 'instancemethod'> Add the specified filter to this handler.

DAL.logger.addHandler	<type 'instancemethod'> belongs to class <type 'instancemethod'> Add the specified handler to this logger.

DAL.logger.callHandlers	<type 'instancemethod'> belongs to class <type 'instancemethod'> Pass a record to all relevant handlers. Loop through all handlers for this logger and its parents in the logger hierarchy. If no handler was found, output a one-off error message to sys.stderr. Stop searching up the hierarchy whenever a logger with the "propagate" attribute set to zero is found - that will be the last logger whose handlers are called.

DAL.logger.critical	<type 'instancemethod'> belongs to class <type 'instancemethod'> Log 'msg % args' with severity 'CRITICAL'. To pass exception information, use the keyword argument exc_info with a true value, e.g. logger.critical("Houston, we have a %s", "major disaster", exc_info=1)

DAL.logger.debug	<type 'instancemethod'> belongs to class <type 'instancemethod'> Log 'msg % args' with severity 'DEBUG'. To pass exception information, use the keyword argument exc_info with a true value, e.g. logger.debug("Houston, we have a %s", "thorny problem", exc_info=1)

DAL.logger.disabled	<type 'int'> belongs to class <type 'int'> int(x=0) -> int or long int(x, base=10) -> int or long Convert a number or string to an integer, or return 0 if no arguments are given. If x is floating point, the conversion truncates towards zero. If x is outside the integer range, the function returns a long instead. If x is not a number or if base is given, then x must be a string or Unicode object representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int('0b100', base=0) 4

DAL.logger.error	<type 'instancemethod'> belongs to class <type 'instancemethod'> Log 'msg % args' with severity 'ERROR'. To pass exception information, use the keyword argument exc_info with a true value, e.g. logger.error("Houston, we have a %s", "major problem", exc_info=1)

DAL.logger.exception	<type 'instancemethod'> belongs to class <type 'instancemethod'> Convenience method for logging an ERROR with exception information.

DAL.logger.fatal	<type 'instancemethod'> belongs to class <type 'instancemethod'> Log 'msg % args' with severity 'CRITICAL'. To pass exception information, use the keyword argument exc_info with a true value, e.g. logger.critical("Houston, we have a %s", "major disaster", exc_info=1)

DAL.logger.filter	<type 'instancemethod'> belongs to class <type 'instancemethod'> Determine if a record is loggable by consulting all the filters. The default is to allow the record to be logged; any filter can veto this and the record is then dropped. Returns a zero value if a record is to be dropped, else non-zero.

DAL.logger.filters	<type 'list'> belongs to class <type 'list'> list() -> new empty list list(iterable) -> new list initialized from iterable's items

DAL.logger.findCaller	<type 'instancemethod'> belongs to class <type 'instancemethod'> Find the stack frame of the caller so that we can note the source file name, line number and function name.

DAL.logger.getChild	<type 'instancemethod'> belongs to class <type 'instancemethod'> Get a logger which is a descendant to this one. This is a convenience method, such that logging.getLogger('abc').getChild('def.ghi') is the same as logging.getLogger('abc.def.ghi') It's useful, for example, when the parent logger is named using __name__ rather than a literal string.

DAL.logger.getEffectiveLevel	<type 'instancemethod'> belongs to class <type 'instancemethod'> Get the effective level for this logger. Loop through this logger and its parents in the logger hierarchy, looking for a non-zero logging level. Return the first one found.

DAL.logger.handle	<type 'instancemethod'> belongs to class <type 'instancemethod'> Call the handlers for the specified record. This method is used for unpickled records received from a socket, as well as those created locally. Logger-level filtering is applied.

DAL.logger.handlers	<type 'list'> belongs to class <type 'list'> list() -> new empty list list(iterable) -> new list initialized from iterable's items

DAL.logger.info	<type 'instancemethod'> belongs to class <type 'instancemethod'> Log 'msg % args' with severity 'INFO'. To pass exception information, use the keyword argument exc_info with a true value, e.g. logger.info("Houston, we have a %s", "interesting problem", exc_info=1)

DAL.logger.isEnabledFor	<type 'instancemethod'> belongs to class <type 'instancemethod'> Is this logger enabled for level 'level'?

DAL.logger.level	<type 'int'> belongs to class <type 'int'> int(x=0) -> int or long int(x, base=10) -> int or long Convert a number or string to an integer, or return 0 if no arguments are given. If x is floating point, the conversion truncates towards zero. If x is outside the integer range, the function returns a long instead. If x is not a number or if base is given, then x must be a string or Unicode object representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int('0b100', base=0) 4

DAL.logger.log	<type 'instancemethod'> belongs to class <type 'instancemethod'> Log 'msg % args' with the integer severity 'level'. To pass exception information, use the keyword argument exc_info with a true value, e.g. logger.log(level, "We have a %s", "mysterious problem", exc_info=1)

DAL.logger.makeRecord	<type 'instancemethod'> belongs to class <type 'instancemethod'> A factory method which can be overridden in subclasses to create specialized LogRecords.

DAL.logger.manager	<class 'logging.Manager'> belongs to class <class 'logging.Manager'> There is [under normal circumstances] just one Manager instance, which holds the hierarchy of loggers.

DAL.logger.name	<type 'str'> belongs to class <type 'str'> str(object='') -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object.

DAL.logger.parent	<class 'logging.RootLogger'> belongs to class <class 'logging.RootLogger'> A root logger is not that different to any other logger, except that it must have a logging level and there is only one instance of it in the hierarchy.

DAL.logger.propagate	<type 'int'> belongs to class <type 'int'> int(x=0) -> int or long int(x, base=10) -> int or long Convert a number or string to an integer, or return 0 if no arguments are given. If x is floating point, the conversion truncates towards zero. If x is outside the integer range, the function returns a long instead. If x is not a number or if base is given, then x must be a string or Unicode object representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int('0b100', base=0) 4

DAL.logger.removeFilter	<type 'instancemethod'> belongs to class <type 'instancemethod'> Remove the specified filter from this handler.

DAL.logger.removeHandler	<type 'instancemethod'> belongs to class <type 'instancemethod'> Remove the specified handler from this logger.

DAL.logger.root	<class 'logging.RootLogger'> belongs to class <class 'logging.RootLogger'> A root logger is not that different to any other logger, except that it must have a logging level and there is only one instance of it in the hierarchy.

DAL.logger.setLevel	<type 'instancemethod'> belongs to class <type 'instancemethod'> Set the logging level of this logger.

DAL.logger.warn	<type 'instancemethod'> belongs to class <type 'instancemethod'> Log 'msg % args' with severity 'WARNING'. To pass exception information, use the keyword argument exc_info with a true value, e.g. logger.warning("Houston, we have a %s", "bit of a problem", exc_info=1)

DAL.logger.warning	<type 'instancemethod'> belongs to class <type 'instancemethod'> Log 'msg % args' with severity 'WARNING'. To pass exception information, use the keyword argument exc_info with a true value, e.g. logger.warning("Houston, we have a %s", "bit of a problem", exc_info=1)