A handler class which sends events to the NT Event Log. Adds a registry entry for the specified application name. If no dllname is provided, win32service.pyd (which contains some basic message placeholders) is used. Note that use of these placeholders will make your event logs big, as the entire message source is held in the log. If you want slimmer logs, you have to pass in the name of your own DLL which contains the message definitions you want to use in the event log.
There are no implemented interfaces.
There are no attributes in this class.
acquire()
Acquire the I/O thread lock.
addFilter(filter)
Add the specified filter to this handler.
close()
Clean up this handler.
You can remove the application name from the registry as a source of event log entries. However, if you do this, you will not be able to see the events as you intended in the Event Log Viewer - it needs to be able to access the registry to get the DLL name.
createLock()
Acquire a thread lock for serializing access to the underlying I/O.
emit(record)
Emit a record.
Determine the message ID, event category and event type. Then log the message in the NT event log.
filter(record)
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.
flush()
Ensure all logging output has been flushed.
This version does nothing and is intended to be implemented by subclasses.
format(record)
Format the specified record.
If a formatter is set, use it. Otherwise, use the default formatter for the module.
getEventCategory(record)
Return the event category for the record.
Override this if you want to specify your own categories. This version returns 0.
getEventType(record)
Return the event type for the record.
Override this if you want to specify your own types. This version does a mapping using the handler's typemap attribute, which is set up in __init__() to a dictionary which contains mappings for DEBUG, INFO, WARNING, ERROR and CRITICAL. If you are using your own levels you will either need to override this method or place a suitable dictionary in the handler's typemap attribute.
getMessageID(record)
Return the message ID for the event record. If you are using your own messages, you could do this by having the msg passed to the logger being an ID rather than a formatting string. Then, in here, you could use a dictionary lookup to get the message ID. This version returns 1, which is the base message ID in win32service.pyd.
handle(record)
Conditionally emit the specified logging record.
Emission depends on filters which may have been added to the handler. Wrap the actual emission of the record with acquisition/release of the I/O thread lock. Returns whether the filter passed the record for emission.
handleError(record)
Handle errors which occur during an emit() call.
This method should be called from handlers when an exception is encountered during an emit() call. If raiseExceptions is false, exceptions get silently ignored. This is what is mostly wanted for a logging system - most users will not care about errors in the logging system, they are more interested in application errors. You could, however, replace this with a custom handler if you wish. The record which was being processed is passed in to this method.
release()
Release the I/O thread lock.
removeFilter(filter)
Remove the specified filter from this handler.
setFormatter(fmt)
Set the formatter for this handler.
setLevel(level)
Set the logging level of this handler.
There are no known subclasses.