log4net

Type converter for Boolean.

Supports conversion from string to bool type. Nicko Cadell Gert Driesen

Interface supported by type converters

This interface supports conversion from arbitrary types to a single target type. See . Nicko Cadell Gert Driesen

Can the source type be converted to the type supported by this object

the type to convert true if the conversion is possible Test if the can be converted to the type supported by this converter.

Convert the source object to the type supported by this object

the object to convert the converted object Converts the to the type supported by this converter.

Can the source type be converted to the type supported by this object

the type to convert true if the conversion is possible Returns true if the is the type.

Convert the source object to the type supported by this object

the object to convert the converted object Uses the method to convert the argument to a . The object cannot be converted to the target type. To check for this condition use the method.

This class implements a patterned string.

This string has embedded patterns that are resolved and expanded when the string is formatted. This class functions similarly to the in that it accepts a pattern and renders it to a string. Unlike the however the PatternString does not render the properties of a specific but of the process in general. The recognized conversion pattern names are: Conversion Pattern Name Effect appdomain Used to output the friendly name of the current AppDomain. date Used to output the date of the logging event in the local time zone. To output the date in universal time use the %utcdate pattern. The date conversion specifier may be followed by a date format specifier enclosed between braces. For example, %date{HH:mm:ss,fff} or %date{dd MMM yyyy HH:mm:ss,fff}. If no date format specifier is given then ISO8601 format is assumed (). The date format specifier admits the same syntax as the time pattern string of the . For better results it is recommended to use the log4net date formatters. These can be specified using one of the strings "ABSOLUTE", "DATE" and "ISO8601" for specifying , and respectively . For example, %date{ISO8601} or %date{ABSOLUTE}. These dedicated date formatters perform significantly better than . env Used to output the a specific environment variable. The key to lookup must be specified within braces and directly following the pattern specifier, e.g. %env{COMPUTERNAME} would include the value of the COMPUTERNAME environment variable. The env pattern is not supported on the .NET Compact Framework. identity Used to output the user name for the currently active user (Principal.Identity.Name). newline Outputs the platform dependent line separator character or characters. This conversion pattern name offers the same performance as using non-portable line separator strings such as "\n", or "\r\n". Thus, it is the preferred way of specifying a line separator. processid Used to output the system process ID for the current process. property Used to output a specific context property. The key to lookup must be specified within braces and directly following the pattern specifier, e.g. %property{user} would include the value from the property that is keyed by the string 'user'. Each property value that is to be included in the log must be specified separately. Properties are stored in logging contexts. By default the log4net:HostName property is set to the name of machine on which the event was originally logged. If no key is specified, e.g. %property then all the keys and their values are printed in a comma separated list. The properties of an event are combined from a number of different contexts. These are listed below in the order in which they are searched. the thread properties The that are set on the current thread. These properties are shared by all events logged on this thread. the global properties The that are set globally. These properties are shared by all the threads in the AppDomain. random Used to output a random string of characters. The string is made up of uppercase letters and numbers. By default the string is 4 characters long. The length of the string can be specified within braces directly following the pattern specifier, e.g. %random{8} would output an 8 character string. username Used to output the WindowsIdentity for the currently active user. utcdate Used to output the date of the logging event in universal time. The date conversion specifier may be followed by a date format specifier enclosed between braces. For example, %utcdate{HH:mm:ss,fff} or %utcdate{dd MMM yyyy HH:mm:ss,fff}. If no date format specifier is given then ISO8601 format is assumed (). The date format specifier admits the same syntax as the time pattern string of the . For better results it is recommended to use the log4net date formatters. These can be specified using one of the strings "ABSOLUTE", "DATE" and "ISO8601" for specifying , and respectively . For example, %utcdate{ISO8601} or %utcdate{ABSOLUTE}. These dedicated date formatters perform significantly better than . % The sequence %% outputs a single percent sign. Additional pattern converters may be registered with a specific instance using or . See the for details on the format modifiers supported by the patterns. Nicko Cadell

Interface used to delay activate a configured object.

This allows an object to defer activation of its options until all options have been set. This is required for components which have related options that remain ambiguous until all are set. If a component implements this interface then the method must be called by the container after its all the configured properties have been set and before the component can be used. Nicko Cadell

Activate the options that were previously set with calls to properties.

This allows an object to defer activation of its options until all options have been set. This is required for components which have related options that remain ambiguous until all are set. If a component implements this interface then this method must be called after its properties have been set before the component can be used.

Internal map of converter identifiers to converter types.

the pattern

the head of the pattern converter chain

patterns defined on this PatternString only

Initialize the global registry

Default constructor

Initialize a new instance of

Constructs a PatternString

The pattern to use with this PatternString Initialize a new instance of with the pattern specified.

Initialize object options

Create the used to parse the pattern

the pattern to parse The Returns PatternParser used to parse the conversion string. Subclasses may override this to return a subclass of PatternParser which recognize custom conversion pattern name.

Produces a formatted string as specified by the conversion pattern.

The TextWriter to write the formatted event to Format the pattern to the .

Format the pattern as a string

the pattern formatted as a string Format the pattern to a string.

Add a converter to this PatternString

the converter info This version of the method is used by the configurator. Programmatic users should use the alternative method.

Add a converter to this PatternString

the name of the conversion pattern for this converter the type of the converter Add a converter to this PatternString

Gets or sets the pattern formatting string

The pattern formatting string The ConversionPattern option. This is the string which controls formatting and consists of a mix of literal content and conversion specifiers.

Wrapper class used to map converter names to converter types

default constructor

Gets or sets the name of the conversion pattern

The name of the conversion pattern Gets or sets the name of the conversion pattern

Gets or sets the type of the converter

The type of the converter Gets or sets the type of the converter

This class aggregates several PropertiesDictionary collections together.

Provides a dictionary style lookup over an ordered list of collections. Nicko Cadell

Constructor

Initializes a new instance of the class.

Add a Properties Dictionary to this composite collection

the properties to add Properties dictionaries added first take precedence over dictionaries added later.

Flatten this composite collection into a single properties dictionary

the flattened dictionary Reduces the collection of ordered dictionaries to a single dictionary containing the resultant values for the keys.

Gets the value of a property

The value for the property with the specified key Looks up the value for the specified. The collections are searched in the order in which they were added to this collection. The value returned is the value held by the first collection that contains the specified key. If none of the collections contain the specified key then null is returned.

Base implementation of

Default abstract implementation of the interface. Skeleton implementation of the interface. All types can extend this type. Nicko Cadell Gert Driesen

Interface implemented by logger repositories.

This interface is implemented by logger repositories. e.g. . This interface is used by the to obtain interfaces. Nicko Cadell Gert Driesen

Check if the named logger exists in the repository. If so return its reference, otherwise returns null.

The name of the logger to lookup The Logger object with the name specified If the names logger exists it is returned, otherwise null is returned.

Returns all the currently defined loggers as an Array.

All the defined loggers Returns all the currently defined loggers as an Array.

Returns a named logger instance

The name of the logger to retrieve The logger object with the name specified Returns a named logger instance. If a logger of that name already exists, then it will be returned. Otherwise, a new logger will be instantiated and then linked with its existing ancestors as well as children.

Shutdown the repository

Shutting down a repository will safely close and remove all appenders in all loggers including the root logger. Some appenders need to be closed before the application exists. Otherwise, pending logging events might be lost. The method is careful to close nested appenders before closing regular appenders. This is allows configurations where a regular appender is attached to a logger and again to a nested appender.

Reset the repositories configuration to a default state

Reset all values contained in this instance to their default state. Existing loggers are not removed. They are just reset. This method should be used sparingly and with care as it will block all logging until it is completed.

Log the through this repository.

the event to log This method should not normally be used to log. The interface should be used for routine logging. This interface can be obtained using the method. The logEvent is delivered to the appropriate logger and that logger is then responsible for logging the event.

Returns all the Appenders that are configured as an Array.

All the Appenders Returns all the Appenders that are configured as an Array.

The name of the repository

The name of the repository The name of the repository.

RendererMap accesses the object renderer map for this repository.

RendererMap accesses the object renderer map for this repository. RendererMap accesses the object renderer map for this repository. The RendererMap holds a mapping between types and objects.

The plugin map for this repository.

The plugin map for this repository. The plugin map holds the instances that have been attached to this repository.

Get the level map for the Repository.

Get the level map for the Repository. The level map defines the mappings between level names and objects in this repository.

The threshold for all events in this repository

The threshold for all events in this repository The threshold for all events in this repository.

Flag indicates if this repository has been configured.

Flag indicates if this repository has been configured. Flag indicates if this repository has been configured.

Event to notify that the repository has been shutdown.

Event to notify that the repository has been shutdown. Event raised when the repository has been shutdown.

Event to notify that the repository has had its configuration reset.

Event to notify that the repository has had its configuration reset. Event raised when the repository's configuration has been reset to default.

Event to notify that the repository has had its configuration changed.

Event to notify that the repository has had its configuration changed. Event raised when the repository's configuration has been changed.

Repository specific properties

Repository specific properties These properties can be specified on a repository specific basis.

Default Constructor

Initializes the repository with default (empty) properties.

Construct the repository using specific properties

the properties to set for this repository Initializes the repository with specified properties.

Test if logger exists

The name of the logger to lookup The Logger object with the name specified Check if the named logger exists in the repository. If so return its reference, otherwise returns null.

Returns all the currently defined loggers in the repository

All the defined loggers Returns all the currently defined loggers in the repository as an Array.

Return a new logger instance

The name of the logger to retrieve The logger object with the name specified Return a new logger instance. If a logger of that name already exists, then it will be returned. Otherwise, a new logger will be instantiated and then linked with its existing ancestors as well as children.

Shutdown the repository

Shutdown the repository. Can be overridden in a subclass. This base class implementation notifies the listeners and all attached plugins of the shutdown event.

Reset the repositories configuration to a default state

Log the logEvent through this repository.

Returns all the Appenders that are configured as an Array.

All the Appenders Returns all the Appenders that are configured as an Array.

Adds an object renderer for a specific class.

The type that will be rendered by the renderer supplied. The object renderer used to render the object. Adds an object renderer for a specific class.

Notify the registered listeners that the repository is shutting down

Empty EventArgs Notify any listeners that this repository is shutting down.

Notify the registered listeners that the repository has had its configuration reset

Empty EventArgs Notify any listeners that this repository's configuration has been reset.

Notify the registered listeners that the repository has had its configuration changed

Empty EventArgs Notify any listeners that this repository's configuration has changed.

Raise a configuration changed event on this repository

EventArgs.Empty Applications that programmatically change the configuration of the repository should raise this event notification to notify listeners.

The name of the repository

The string name of the repository The name of this repository. The name is used to store and lookup the repositories stored by the .

The threshold for all events in this repository

The threshold for all events in this repository The threshold for all events in this repository

RendererMap accesses the object renderer map for this repository.

RendererMap accesses the object renderer map for this repository. RendererMap accesses the object renderer map for this repository. The RendererMap holds a mapping between types and objects.

The plugin map for this repository.

The plugin map for this repository. The plugin map holds the instances that have been attached to this repository.

Get the level map for the Repository.

Get the level map for the Repository. The level map defines the mappings between level names and objects in this repository.

Flag indicates if this repository has been configured.

Flag indicates if this repository has been configured. Flag indicates if this repository has been configured.

Event to notify that the repository has been shutdown.

Event to notify that the repository has been shutdown. Event raised when the repository has been shutdown.

Event to notify that the repository has had its configuration reset.

Event to notify that the repository has had its configuration reset. Event raised when the repository's configuration has been reset to default.

Event to notify that the repository has had its configuration changed.

Event to notify that the repository has had its configuration changed. Event raised when the repository's configuration has been changed.

Repository specific properties

Repository specific properties These properties can be specified on a repository specific basis

Implementation of used by

Internal class used to provide implementation of interface. Applications should use to get logger instances. This is one of the central classes in the log4net implementation. One of the distinctive features of log4net are hierarchical loggers and their evaluation. The organizes the instances into a rooted tree hierarchy. The class is abstract. Only concrete subclasses of can be created. The is used to create instances of this type for the . Nicko Cadell Gert Driesen Aspi Havewala Douglas de la Torre

Interface for attaching appenders to objects.

Interface for attaching, removing and retrieving appenders. Nicko Cadell Gert Driesen

Attaches an appender.

The appender to add. Add the specified appender. The implementation may choose to allow or deny duplicate appenders.

Gets an attached appender with the specified name.

The name of the appender to get. The appender with the name specified, or null if no appender with the specified name is found. Returns an attached appender with the specified. If no appender with the specified name is found null will be returned.

Removes all attached appenders.

Removes and closes all attached appenders

Removes the specified appender from the list of attached appenders.

The appender to remove. The appender removed from the list The appender removed is not closed. If you are discarding the appender you must call on the appender removed.

Removes the appender with the specified name from the list of appenders.

The name of the appender to remove. The appender removed from the list The appender removed is not closed. If you are discarding the appender you must call on the appender removed.

Gets all attached appenders.

A collection of attached appenders. Gets a collection of attached appenders. If there are no attached appenders the implementation should return an empty collection rather than null.

Interface that all loggers implement

This interface supports logging events and testing if a level is enabled for logging. These methods will not throw exceptions. Note to implementor, ensure that the implementation of these methods cannot allow an exception to be thrown to the caller. Nicko Cadell Gert Driesen

This generic form is intended to be used by wrappers.

The declaring type of the method that is the stack boundary into the logging system for this call. The level of the message to be logged. The message object to log. the exception to log, including its stack trace. Pass null to not log an exception. Generates a logging event for the specified using the and .

This is the most generic printing method that is intended to be used by wrappers.

The event being logged. Logs the specified logging event through this logger.

Checks if this logger is enabled for a given passed as parameter.

The level to check. true if this logger is enabled for level, otherwise false. Test if this logger is going to log events of the specified .

Gets the name of the logger.

The name of the logger. The name of this logger

Gets the where this Logger instance is attached to.

The that this logger belongs to. Gets the where this Logger instance is attached to.

This constructor created a new instance and sets its name.

The name of the . This constructor is protected and designed to be used by a subclass that is not abstract. Loggers are constructed by objects. See for the default logger creator.

Add to the list of appenders of this Logger instance.

An appender to add to this logger Add to the list of appenders of this Logger instance. If is already in the list of appenders, then it won't be added again.

Look for the appender named as name

The name of the appender to lookup The appender with the name specified, or null. Returns the named appender, or null if the appender is not found.

Remove all previously added appenders from this Logger instance.

Remove all previously added appenders from this Logger instance. This is useful when re-reading configuration information.

Remove the appender passed as parameter form the list of appenders.

The appender to remove The appender removed from the list Remove the appender passed as parameter form the list of appenders. The appender removed is not closed. If you are discarding the appender you must call on the appender removed.

Remove the appender passed as parameter form the list of appenders.

The name of the appender to remove The appender removed from the list Remove the named appender passed as parameter form the list of appenders. The appender removed is not closed. If you are discarding the appender you must call on the appender removed.

This generic form is intended to be used by wrappers.

The declaring type of the method that is the stack boundary into the logging system for this call. The level of the message to be logged. The message object to log. The exception to log, including its stack trace. Generate a logging event for the specified using the and . This method must not throw any exception to the caller.

This is the most generic printing method that is intended to be used by wrappers.

The event being logged. Logs the specified logging event through this logger. This method must not throw any exception to the caller.

Checks if this logger is enabled for a given passed as parameter.

The level to check. true if this logger is enabled for level, otherwise false. Test if this logger is going to log events of the specified . This method must not throw any exception to the caller.

Deliver the to the attached appenders.

The event to log. Call the appenders in the hierarchy starting at this. If no appenders could be found, emit a warning. This method calls all the appenders inherited from the hierarchy circumventing any evaluation of whether to log or not to log the particular log request.

Closes all attached appenders implementing the interface.

Used to ensure that the appenders are correctly shutdown.

This is the most generic printing method. This generic form is intended to be used by wrappers

The level of the message to be logged. The message object to log. The exception to log, including its stack trace. Generate a logging event for the specified using the .

Creates a new logging event and logs the event without further checks.

The declaring type of the method that is the stack boundary into the logging system for this call. The level of the message to be logged. The message object to log. The exception to log, including its stack trace. Generates a logging event and delivers it to the attached appenders.

Creates a new logging event and logs the event without further checks.

The event being logged. Delivers the logging event to the attached appenders.

The fully qualified type of the Logger class.

The name of this logger.

The assigned level of this logger.

The level variable need not be assigned a value in which case it is inherited form the hierarchy.

The parent of this logger.

The parent of this logger. All loggers have at least one ancestor which is the root logger.

Loggers need to know what Hierarchy they are in.

Loggers need to know what Hierarchy they are in. The hierarchy that this logger is a member of is stored here.

Helper implementation of the interface

Flag indicating if child loggers inherit their parents appenders

Additivity is set to true by default, that is children inherit the appenders of their ancestors by default. If this variable is set to false then the appenders found in the ancestors of this logger are not used. However, the children of this logger will inherit its appenders, unless the children have their additivity flag set to false too. See the user manual for more details.

Lock to protect AppenderAttachedImpl variable m_appenderAttachedImpl

Gets or sets the parent logger in the hierarchy.

The parent logger in the hierarchy. Part of the Composite pattern that makes the hierarchy. The hierarchy is parent linked rather than child linked.

Gets or sets a value indicating if child loggers inherit their parent's appenders.

true if child loggers inherit their parent's appenders. Additivity is set to true by default, that is children inherit the appenders of their ancestors by default. If this variable is set to false then the appenders found in the ancestors of this logger are not used. However, the children of this logger will inherit its appenders, unless the children have their additivity flag set to false too. See the user manual for more details.

Gets the effective level for this logger.

The nearest level in the logger hierarchy. Starting from this logger, searches the logger hierarchy for a non-null level and returns it. Otherwise, returns the level of the root logger. The Logger class is designed so that this method executes as quickly as possible.

Gets or sets the where this Logger instance is attached to.

The hierarchy that this logger belongs to. This logger must be attached to a single .

Gets or sets the assigned , if any, for this Logger.

The of this logger. The assigned can be null.

Get the appenders contained in this logger as an .

A collection of the appenders in this logger Get the appenders contained in this logger as an . If no appenders can be found, then a is returned.

Gets the logger name.

The name of the logger. The name of this logger

Gets the where this Logger instance is attached to.

The that this logger belongs to. Gets the where this Logger instance is attached to.

Layout that formats the log events as XML elements compatible with the log4j schema

Formats the log events according to the http://logging.apache.org/log4j schema. Nicko Cadell

Layout that formats the log events as XML elements.

This is an abstract class that must be subclassed by an implementation to conform to a specific schema. Deriving classes must implement the method. Nicko Cadell Gert Driesen

Extend this abstract class to create your own log layout format.

This is the base implementation of the interface. Most layout objects should extend this class. Subclasses must implement the method. Subclasses should set the in their default constructor. Nicko Cadell Gert Driesen

Interface implemented by layout objects

An object is used to format a as text. The method is called by an appender to transform the into a string. The layout can also supply and text that is appender before any events and after all the events respectively. Nicko Cadell Gert Driesen

Implement this method to create your own layout format.

The TextWriter to write the formatted event to The event to format This method is called by an appender to format the as text and output to a writer. If the caller does not have a and prefers the event to be formatted as a then the following code can be used to format the event into a .


            StringWriter writer = new StringWriter();
            Layout.Format(writer, loggingEvent);
            string formattedEvent = writer.ToString();

The content type output by this layout.

The content type The content type output by this layout. This is a MIME type e.g. "text/plain".

The header for the layout format.

the layout header The Header text will be appended before any logging events are formatted and appended.

The footer for the layout format.

the layout footer The Footer text will be appended after all the logging events have been formatted and appended.

Flag indicating if this layout handle exceptions

The header text

See for more information.

The footer text

See for more information.

Flag indicating if this layout handles exceptions

false if this layout handles exceptions

Empty default constructor

Activate component options

Implement this method to create your own layout format.

The TextWriter to write the formatted event to The event to format This method is called by an appender to format the as text.

The content type output by this layout.

The content type is "text/plain" The content type output by this layout. This base class uses the value "text/plain". To change this value a subclass must override this property.

The header for the layout format.

the layout header The Header text will be appended before any logging events are formatted and appended.

The footer for the layout format.

the layout footer The Footer text will be appended after all the logging events have been formatted and appended.

Flag indicating if this layout handles exceptions

false if this layout handles exceptions If this layout handles the exception object contained within , then the layout should return false. Otherwise, if the layout ignores the exception object, then the layout should return true. Set this value to override a this default setting. The default value is true, this layout does not handle the exception.

Protected constructor to support subclasses

Initializes a new instance of the class with no location info.

Protected constructor to support subclasses

The parameter determines whether location information will be output by the layout. If is set to true, then the file name and line number of the statement at the origin of the log statement will be output. If you are embedding this layout within an SMTPAppender then make sure to set the LocationInfo option of that appender as well.

Initialize layout options

Produces a formatted string.

The event being logged. The TextWriter to write the formatted event to Format the and write it to the . This method creates an that writes to the . The is passed to the method. Subclasses should override the method rather than this method.

Does the actual writing of the XML.

The writer to use to output the event to. The event to write. Subclasses should override this method to format the as XML.

Flag to indicate if location information should be included in the XML events.

Writer adapter that ignores Close

The string to replace invalid chars with

Gets a value indicating whether to include location information in the XML events.

true if location information should be included in the XML events; otherwise, false. If is set to true, then the file name and line number of the statement at the origin of the log statement will be output. If you are embedding this layout within an SMTPAppender then make sure to set the LocationInfo option of that appender as well.

The string to replace characters that can not be expressed in XML with. Not all characters may be expressed in XML. This property contains the string to replace those that can not with. This defaults to a ?. Set it to the empty string to simply remove offending characters. For more details on the allowed character ranges see http://www.w3.org/TR/REC-xml/#charsets Character replacement will occur in the log message, the property names and the property values.

Gets the content type output by this layout.

As this is the XML layout, the value is always "text/xml". As this is the XML layout, the value is always "text/xml".

The 1st of January 1970 in UTC

Constructs an XMLLayoutSchemaLog4j

Constructs an XMLLayoutSchemaLog4j.

The LocationInfo option takes a boolean value. By default, it is set to false which means there will be no location information output by this layout. If the the option is set to true, then the file name and line number of the statement at the origin of the log statement will be output. If you are embedding this layout within an SMTPAppender then make sure to set the LocationInfo option of that appender as well.

Actually do the writing of the xml

the writer to use the event to write Generate XML that is compatible with the log4j schema.

The version of the log4j schema to use.

Only version 1.2 of the log4j schema is supported.

Converter to output the relative time of the event

Converter to output the time of the event relative to the start of the program. Nicko Cadell

Abstract class that provides the formatting functionality that derived classes need.

Conversion specifiers in a conversion patterns are parsed to individual PatternConverters. Each of which is responsible for converting a logging event in a converter specific manner. Nicko Cadell

Abstract class that provides the formatting functionality that derived classes need.

Conversion specifiers in a conversion patterns are parsed to individual PatternConverters. Each of which is responsible for converting a logging event in a converter specific manner. Nicko Cadell Gert Driesen

Initial buffer size

Maximum buffer size before it is recycled

Protected constructor

Initializes a new instance of the class.

Evaluate this pattern converter and write the output to a writer.

that will receive the formatted result. The state object on which the pattern converter should be executed. Derived pattern converters must override this method in order to convert conversion specifiers in the appropriate way.

Set the next pattern converter in the chains

the pattern converter that should follow this converter in the chain the next converter The PatternConverter can merge with its neighbor during this method (or a sub class). Therefore the return value may or may not be the value of the argument passed in.

Write the pattern converter to the writer with appropriate formatting

that will receive the formatted result. The state object on which the pattern converter should be executed. This method calls to allow the subclass to perform appropriate conversion of the pattern converter. If formatting options have been specified via the then this method will apply those formattings before writing the output.

Fast space padding method.

to which the spaces will be appended. The number of spaces to be padded. Fast space padding method.

The option string to the converter

Write an dictionary to a

the writer to write to a to use for object conversion the value to write to the writer Writes the to a writer in the form:


            {key1=value1, key2=value2, key3=value3}

If the specified is not null then it is used to render the key and value to text, otherwise the object's ToString method is called.

Write an object to a

the writer to write to a to use for object conversion the value to write to the writer Writes the Object to a writer. If the specified is not null then it is used to render the object to text, otherwise the object's ToString method is called.

Get the next pattern converter in the chain

the next pattern converter in the chain Get the next pattern converter in the chain

Gets or sets the formatting info for this converter

The formatting info for this converter Gets or sets the formatting info for this converter

Gets or sets the option value for this converter

The option for this converter

Gets or sets the option value for this converter

Initializes a new instance of the class.

Derived pattern converters must override this method in order to convert conversion specifiers in the correct way.

that will receive the formatted result. The on which the pattern converter should be executed.

Derived pattern converters must override this method in order to convert conversion specifiers in the correct way.

that will receive the formatted result. The state object on which the pattern converter should be executed.

Flag indicating if this converter handles exceptions

false if this converter handles exceptions

Flag indicating if this converter handles the logging event exception

false if this converter handles the logging event exception If this converter handles the exception object contained within , then this property should be set to false. Otherwise, if the layout ignores the exception object, then the property should be set to true. Set this value to override a this default setting. The default value is true, this converter does not handle the exception.

Write the relative time to the output

that will receive the formatted result. the event being logged Writes out the relative time of the event in milliseconds. That is the number of milliseconds between the event and the .

Helper method to get the time difference between two DateTime objects

start time (in the current local time zone) end time (in the current local time zone) the time difference in milliseconds

Converter to include event NDC

Outputs the value of the event property named NDC. The should be used instead. Nicko Cadell

Write the event NDC to the output

that will receive the formatted result. the event being logged As the thread context stacks are now stored in named event properties this converter simply looks up the value of the NDC property. The should be used instead.

Write the exception text to the output

If an exception object is stored in the logging event it will be rendered into the pattern output with a trailing newline. If there is no exception then nothing will be output and no trailing newline will be appended. It is typical to put a newline before the exception and to have the exception as the last data in the pattern. Nicko Cadell

Default constructor

A Layout that renders only the Exception text from the logging event

A Layout that renders only the Exception text from the logging event. This Layout should only be used with appenders that utilize multiple layouts (e.g. ). Nicko Cadell Gert Driesen

Default constructor

Constructs a ExceptionLayout

Activate component options

Part of the component activation framework. This method does nothing as options become effective immediately.

Gets the exception text from the logging event

The TextWriter to write the formatted event to the event being logged Write the exception string to the . The exception string is retrieved from .

This filter drops all .

You can add this filter to the end of a filter chain to switch from the default "accept all unless instructed otherwise" filtering behavior to a "deny all unless instructed otherwise" behavior. Nicko Cadell Gert Driesen

Subclass this type to implement customized logging event filtering

Users should extend this class to implement customized logging event filtering. Note that and , the parent class of all standard appenders, have built-in filtering rules. It is suggested that you first use and understand the built-in rules before rushing to write your own custom filters. This abstract class assumes and also imposes that filters be organized in a linear chain. The method of each filter is called sequentially, in the order of their addition to the chain. The method must return one of the integer constants , or . If the value is returned, then the log event is dropped immediately without consulting with the remaining filters. If the value is returned, then the next filter in the chain is consulted. If there are no more filters in the chain, then the log event is logged. Thus, in the presence of no filters, the default behavior is to log all logging events. If the value is returned, then the log event is logged without consulting the remaining filters. The philosophy of log4net filters is largely inspired from the Linux ipchains. Nicko Cadell Gert Driesen

Implement this interface to provide customized logging event filtering

Users should implement this interface to implement customized logging event filtering. Note that and , the parent class of all standard appenders, have built-in filtering rules. It is suggested that you first use and understand the built-in rules before rushing to write your own custom filters. This abstract class assumes and also imposes that filters be organized in a linear chain. The method of each filter is called sequentially, in the order of their addition to the chain. The method must return one of the integer constants , or . If the value is returned, then the log event is dropped immediately without consulting with the remaining filters. If the value is returned, then the next filter in the chain is consulted. If there are no more filters in the chain, then the log event is logged. Thus, in the presence of no filters, the default behavior is to log all logging events. If the value is returned, then the log event is logged without consulting the remaining filters. The philosophy of log4net filters is largely inspired from the Linux ipchains. Nicko Cadell Gert Driesen

Decide if the logging event should be logged through an appender.

The LoggingEvent to decide upon The decision of the filter If the decision is , then the event will be dropped. If the decision is , then the next filter, if any, will be invoked. If the decision is then the event will be logged without consulting with other filters in the chain.

Property to get and set the next filter

The next filter in the chain Filters are typically composed into chains. This property allows the next filter in the chain to be accessed.

Points to the next filter in the filter chain.

See for more information.

Initialize the filter with the options set

This is part of the delayed object activation scheme. The method must be called on this object after the configuration properties have been set. Until is called this object is in an undefined state and must not be used. If any of the configuration properties are modified then must be called again. Typically filter's options become active immediately on set, however this method must still be called.

Decide if the should be logged through an appender.

The to decide upon The decision of the filter If the decision is , then the event will be dropped. If the decision is , then the next filter, if any, will be invoked. If the decision is then the event will be logged without consulting with other filters in the chain. This method is marked abstract and must be implemented in a subclass.

Property to get and set the next filter

The next filter in the chain Filters are typically composed into chains. This property allows the next filter in the chain to be accessed.

Default constructor

Always returns the integer constant

the LoggingEvent to filter Always returns Ignores the event being logged and just returns . This can be used to change the default filter chain behavior from to . This filter should only be used as the last filter in the chain as any further filters will be ignored!

Formats the using the method.

Formats the using the method. Nicko Cadell Gert Driesen

Render a as a string.

Interface to abstract the rendering of a instance into a string. The method is used to render the date to a text writer. Nicko Cadell Gert Driesen

Formats the specified date as a string.

The date to format. The writer to write to. Format the as a string and write it to the provided.

Constructor

The format string. Initializes a new instance of the class with the specified format string. The format string must be compatible with the options that can be supplied to .

Formats the date using .

The date to convert to a string. The writer to write to. Uses the date format string supplied to the constructor to call the method to format the date.

The format string used to format the .

The format string must be compatible with the options that can be supplied to .

The internal representation of caller location information.

This class uses the System.Diagnostics.StackTrace class to generate a call stack. The caller's information is then extracted from this stack. The System.Diagnostics.StackTrace class is not supported on the .NET Compact Framework 1.0 therefore caller location information is not available on that framework. The System.Diagnostics.StackTrace class has this to say about Release builds: "StackTrace information will be most informative with Debug build configurations. By default, Debug builds include debug symbols, while Release builds do not. The debug symbols contain most of the file, method name, line number, and column information used in constructing StackFrame and StackTrace objects. StackTrace might not report as many method calls as expected, due to code transformations that occur during optimization." This means that in a Release build the caller information may be incomplete or may not exist at all! Therefore caller location information cannot be relied upon in a Release build. Nicko Cadell Gert Driesen

When location information is not available the constant NA is returned. Current value of this string constant is ?.

Constructor

The declaring type of the method that is the stack boundary into the logging system for this call. Initializes a new instance of the class based on the current thread.

Constructor

The fully qualified class name. The method name. The file name. The line number of the method within the file. Initializes a new instance of the class with the specified data.

Gets the fully qualified class name of the caller making the logging request.

The fully qualified class name of the caller making the logging request. Gets the fully qualified class name of the caller making the logging request.

Gets the file name of the caller.

The file name of the caller. Gets the file name of the caller.

Gets the line number of the caller.

The line number of the caller. Gets the line number of the caller.

Gets the method name of the caller.

The method name of the caller. Gets the method name of the caller.

Gets all available caller information

All available caller information, in the format fully.qualified.classname.of.caller.methodName(Filename:line) Gets all available caller information, in the format fully.qualified.classname.of.caller.methodName(Filename:line)

Mapping between string name and Level object

Mapping between string name and object. This mapping is held separately for each . The level name is case insensitive. Nicko Cadell

Mapping from level name to Level object. The level name is case insensitive

Construct the level map

Construct the level map.

Clear the internal maps of all levels

Create a new Level and add it to the map

the string to display for the Level the level value to give to the Level Create a new Level and add it to the map

Create a new Level and add it to the map

the string to display for the Level the level value to give to the Level the display name to give to the Level Create a new Level and add it to the map

Add a Level to the map

the Level to add Add a Level to the map

Lookup a named level from the map

the name of the level to lookup is taken from this level. If the level is not set on the map then this level is added the level in the map with the name specified Lookup a named level from the map. The name of the level to lookup is taken from the property of the argument. If no level with the specified name is found then the argument is added to the level map and returned.

Lookup a by name

The name of the Level to lookup a Level from the map with the name specified Returns the from the map with the name specified. If the no level is found then null is returned.

Return all possible levels as a list of Level objects.

all possible levels as a list of Level objects Return all possible levels as a list of Level objects.

Appender that logs to a database.

appends logging events to a table within a database. The appender can be configured to specify the connection string by setting the property. The connection type (provider) can be specified by setting the property. For more information on database connection strings for your specific database see http://www.connectionstrings.com/. Records are written into the database either using a prepared statement or a stored procedure. The property is set to (System.Data.CommandType.Text) to specify a prepared statement or to (System.Data.CommandType.StoredProcedure) to specify a stored procedure. The prepared statement text or the name of the stored procedure must be set in the property. The prepared statement or stored procedure can take a number of parameters. Parameters are added using the method. This adds a single to the ordered list of parameters. The type may be subclassed if required to provide database specific functionality. The specifies the parameter name, database type, size, and how the value should be generated using a . An example of a SQL Server table that could be logged to:


            CREATE TABLE [dbo].[Log] ( 
              [ID] [int] IDENTITY (1, 1) NOT NULL ,
              [Date] [datetime] NOT NULL ,
              [Thread] [varchar] (255) NOT NULL ,
              [Level] [varchar] (20) NOT NULL ,
              [Logger] [varchar] (255) NOT NULL ,
              [Message] [varchar] (4000) NOT NULL 
            ) ON [PRIMARY]

An example configuration to log to the above table:

Julian Biddle Nicko Cadell Gert Driesen Lance Nehring

Abstract base class implementation of that buffers events in a fixed size buffer.

This base class should be used by appenders that need to buffer a number of events before logging them. For example the buffers events and then submits the entire contents of the buffer to the underlying database in one go. Subclasses should override the method to deliver the buffered events. The BufferingAppenderSkeleton maintains a fixed size cyclic buffer of events. The size of the buffer is set using the property. A is used to inspect each event as it arrives in the appender. If the triggers, then the current buffer is sent immediately (see ). Otherwise the event is stored in the buffer. For example, an evaluator can be used to deliver the events immediately when an ERROR event arrives. The buffering appender can be configured in a mode. By default the appender is NOT lossy. When the buffer is full all the buffered events are sent with . If the property is set to true then the buffer will not be sent when it is full, and new events arriving in the appender will overwrite the oldest event in the buffer. In lossy mode the buffer will only be sent when the triggers. This can be useful behavior when you need to know about ERROR events but not about events with a lower level, configure an evaluator that will trigger when an ERROR event arrives, the whole buffer will be sent which gives a history of events leading up to the ERROR event. Nicko Cadell Gert Driesen

Abstract base class implementation of .

This class provides the code for common functionality, such as support for threshold filtering and support for general filters. Appenders can also implement the interface. Therefore they would require that the method be called after the appenders properties have been configured. Nicko Cadell Gert Driesen

Implement this interface for your own strategies for printing log statements.

Implementors should consider extending the class which provides a default implementation of this interface. Appenders can also implement the interface. Therefore they would require that the method be called after the appenders properties have been configured. Nicko Cadell Gert Driesen

Closes the appender and releases resources.

Releases any resources allocated within the appender such as file handles, network connections, etc. It is a programming error to append to a closed appender.

Log the logging event in Appender specific way.

The event to log This method is called to log a message into this appender.

Gets or sets the name of this appender.

The name of the appender. The name uniquely identifies the appender.

Interface for appenders that support bulk logging.

This interface extends the interface to support bulk logging of objects. Appenders should only implement this interface if they can bulk log efficiently. Nicko Cadell

Log the array of logging events in Appender specific way.

The events to log This method is called to log an array of events into this appender.

Initial buffer size

Maximum buffer size before it is recycled

Default constructor

Empty default constructor

Finalizes this appender by calling the implementation's method.

If this appender has not been closed then the Finalize method will call .

Initialize the appender based on the options set

Closes the appender and release resources.

Release any resources allocated within the appender such as file handles, network connections, etc. It is a programming error to append to a closed appender. This method cannot be overridden by subclasses. This method delegates the closing of the appender to the method which must be overridden in the subclass.

Performs threshold checks and invokes filters before delegating actual logging to the subclasses specific method.

The event to log. This method cannot be overridden by derived classes. A derived class should override the method which is called by this method. The implementation of this method is as follows: Checks that the severity of the is greater than or equal to the of this appender. Checks that the chain accepts the . Calls and checks that it returns true. If all of the above steps succeed then the will be passed to the abstract method.

Performs threshold checks and invokes filters before delegating actual logging to the subclasses specific method.

The array of events to log. This method cannot be overridden by derived classes. A derived class should override the method which is called by this method. The implementation of this method is as follows: Checks that the severity of the is greater than or equal to the of this appender. Checks that the chain accepts the . Calls and checks that it returns true. If all of the above steps succeed then the will be passed to the method.

Test if the logging event should we output by this appender

the event to test true if the event should be output, false if the event should be ignored This method checks the logging event against the threshold level set on this appender and also against the filters specified on this appender. The implementation of this method is as follows: Checks that the severity of the is greater than or equal to the of this appender. Checks that the chain accepts the .

Adds a filter to the end of the filter chain.

the filter to add to this appender The Filters are organized in a linked list. Setting this property causes the new filter to be pushed onto the back of the filter chain.

Clears the filter list for this appender.

Checks if the message level is below this appender's threshold.

to test against. If there is no threshold set, then the return value is always true. true if the meets the requirements of this appender.

Is called when the appender is closed. Derived classes should override this method if resources need to be released.

Releases any resources allocated within the appender such as file handles, network connections, etc. It is a programming error to append to a closed appender.

Subclasses of should implement this method to perform actual logging.

The event to append. A subclass must implement this method to perform logging of the . This method will be called by if all the conditions listed for that method are met. To restrict the logging of events in the appender override the method.

Append a bulk array of logging events.

the array of logging events This base class implementation calls the method for each element in the bulk array. A sub class that can better process a bulk array of events should override this method in addition to .

Called before as a precondition.

This method is called by before the call to the abstract method. This method can be overridden in a subclass to extend the checks made before the event is passed to the method. A subclass should ensure that they delegate this call to this base class if it is overridden. true if the call to should proceed.

Renders the to a string.

The event to render. The event rendered as a string. Helper method to render a to a string. This appender must have a set to render the to a string. If there is exception data in the logging event and the layout does not process the exception, this method will append the exception text to the rendered string. Where possible use the alternative version of this method . That method streams the rendering onto an existing Writer which can give better performance if the caller already has a open and ready for writing.

Renders the to a string.

The event to render. The TextWriter to write the formatted event to Helper method to render a to a string. This appender must have a set to render the to a string. If there is exception data in the logging event and the layout does not process the exception, this method will append the exception text to the rendered string. Use this method in preference to where possible. If, however, the caller needs to render the event to a string then does provide an efficient mechanism for doing so.

The layout of this appender.

See for more information.

The name of this appender.

See for more information.

The level threshold of this appender.

There is no level threshold filtering by default. See for more information.

It is assumed and enforced that errorHandler is never null.

It is assumed and enforced that errorHandler is never null. See for more information.

The first filter in the filter chain.

Set to null initially. See for more information.

The last filter in the filter chain.

See for more information.

Flag indicating if this appender is closed.

See for more information.

The guard prevents an appender from repeatedly calling its own DoAppend method

StringWriter used to render events

Gets or sets the threshold of this appender.

The threshold of the appender. All log events with lower level than the threshold level are ignored by the appender. In configuration files this option is specified by setting the value of the option to a level string, such as "DEBUG", "INFO" and so on.

Gets or sets the for this appender.

The of the appender The provides a default implementation for the property.

The filter chain.

The head of the filter chain filter chain. Returns the head Filter. The Filters are organized in a linked list and so all Filters on this Appender are available through the result.

Gets or sets the for this appender.

The layout of the appender. See for more information.

Gets or sets the name of this appender.

The name of the appender. The name uniquely identifies the appender.

Tests if this appender requires a to be set.

In the rather exceptional case, where the appender implementation admits a layout but can also work without it, then the appender should return true. This default implementation always returns true. true if the appender requires a layout object, otherwise false.

The default buffer size.

The default size of the cyclic buffer used to store events. This is set to 512 by default.

Initializes a new instance of the class.

Protected default constructor to allow subclassing.

Initializes a new instance of the class.

the events passed through this appender must be fixed by the time that they arrive in the derived class' SendBuffer method. Protected constructor to allow subclassing. The should be set if the subclass expects the events delivered to be fixed even if the is set to zero, i.e. when no buffering occurs.

Flush the currently buffered events

Flushes any events that have been buffered. If the appender is buffering in mode then the contents of the buffer will NOT be flushed to the appender.

Flush the currently buffered events

set to true to flush the buffer of lossy events Flushes events that have been buffered. If is false then events will only be flushed if this buffer is non-lossy mode. If the appender is buffering in mode then the contents of the buffer will only be flushed if is true. In this case the contents of the buffer will be tested against the and if triggering will be output. All other buffered events will be discarded. If is true then the buffer will always be emptied by calling this method.

Initialize the appender based on the options set

Close this appender instance.

Close this appender instance. If this appender is marked as not then the remaining events in the buffer must be sent when the appender is closed.

This method is called by the method.

the event to log Stores the in the cyclic buffer. The buffer will be sent (i.e. passed to the method) if one of the following conditions is met: The cyclic buffer is full and this appender is marked as not lossy (see ) An is set and it is triggered for the specified. Before the event is stored in the buffer it is fixed (see ) to ensure that any data referenced by the event will be valid when the buffer is processed.

Sends the contents of the buffer.

The first logging event. The buffer containing the events that need to be send. The subclass must override .

Sends the events.

The events that need to be send. The subclass must override this method to process the buffered events.

The size of the cyclic buffer used to hold the logging events.

Set to by default.

The cyclic buffer used to store the logging events.

The triggering event evaluator that causes the buffer to be sent immediately.

The object that is used to determine if an event causes the entire buffer to be sent immediately. This field can be null, which indicates that event triggering is not to be done. The evaluator can be set using the property. If this appender has the ( property) set to true then an must be set.

Indicates if the appender should overwrite events in the cyclic buffer when it becomes full, or if the buffer should be flushed when the buffer is full.

If this field is set to true then an must be set.

The triggering event evaluator filters discarded events.

The object that is used to determine if an event that is discarded should really be discarded or if it should be sent to the appenders. This field can be null, which indicates that all discarded events will be discarded.

Value indicating which fields in the event should be fixed

By default all fields are fixed

The events delivered to the subclass must be fixed.

Gets or sets a value that indicates whether the appender is lossy.

true if the appender is lossy, otherwise false. The default is false. This appender uses a buffer to store logging events before delivering them. A triggering event causes the whole buffer to be send to the remote sink. If the buffer overruns before a triggering event then logging events could be lost. Set to false to prevent logging events from being lost. If is set to true then an must be specified.

Gets or sets the size of the cyclic buffer used to hold the logging events.

The size of the cyclic buffer used to hold the logging events. The option takes a positive integer representing the maximum number of logging events to collect in a cyclic buffer. When the is reached, oldest events are deleted as new events are added to the buffer. By default the size of the cyclic buffer is 512 events. If the is set to a value less than or equal to 1 then no buffering will occur. The logging event will be delivered synchronously (depending on the and properties). Otherwise the event will be buffered.

Gets or sets the that causes the buffer to be sent immediately.

The that causes the buffer to be sent immediately. The evaluator will be called for each event that is appended to this appender. If the evaluator triggers then the current buffer will immediately be sent (see ). If is set to true then an must be specified.

Gets or sets the value of the to use.

The value of the to use. The evaluator will be called for each event that is discarded from this appender. If the evaluator triggers then the current buffer will immediately be sent (see ).

Gets or sets a value indicating if only part of the logging event data should be fixed.

true if the appender should only fix part of the logging event data, otherwise false. The default is false. Setting this property to true will cause only part of the event data to be fixed and serialized. This will improve performance. See for more information.

Gets or sets a the fields that will be fixed in the event

The event fields that will be fixed before the event is buffered The logging event needs to have certain thread specific values captured before it can be buffered. See for details.

Initializes a new instance of the class.

Public default constructor to initialize a new instance of this class.

Initialize the appender based on the options set

Override the parent method to close the database

Closes the database command and database connection.

Inserts the events into the database.

The events to insert into the database. Insert all the events specified in the array into the database.

Adds a parameter to the command.

The parameter to add to the command. Adds a parameter to the ordered list of command parameters.

Writes the events to the database using the transaction specified.

The transaction that the events will be executed under. The array of events to insert into the database. The transaction argument can be null if the appender has been configured not to use transactions. See property for more information.

Formats the log message into database statement text.

The event being logged. This method can be overridden by subclasses to provide more control over the format of the database statement. Text that can be passed to a .

Connects to the database.

Retrieves the class type of the ADO.NET provider.

Gets the Type of the ADO.NET provider to use to connect to the database. This method resolves the type specified in the property. Subclasses can override this method to return a different type if necessary. The of the ADO.NET provider

Prepares the database command and initialize the parameters.

Flag to indicate if we are using a command object

Set to true when the appender is to use a prepared statement or stored procedure to insert into the database.

The list of objects.

The security context to use for privileged calls

The that will be used to insert logging events into a database.

The database command.

Database connection string.

Name of the Connection string setting within the ConnectionStrings area.

String type name of the type name.

The text of the command.

The command type.

Indicates whether to use transactions when writing to the database.

Gets or sets the database connection string that is used to connect to the database.

The database connection string used to connect to the database. The connections string is specific to the connection type. See for more information. Connection string for MS Access via ODBC:

"DSN=MS Access Database;UID=admin;PWD=;SystemDB=C:\data\System.mdw;SafeTransactions = 0;FIL=MS Access;DriverID = 25;DBQ=C:\data\train33.mdb"

Another connection string for MS Access via ODBC: "Driver={Microsoft Access Driver (*.mdb)};DBQ=C:\Work\cvs_root\log4net-1.2\access.mdb;UID=;PWD=;" Connection string for MS Access via OLE DB: "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Work\cvs_root\log4net-1.2\access.mdb;User Id=;Password=;"

Gets or set the name of a connection string specified in the ConnectionStrings section of an App.config or Web.config file used to connect to the database.

The name of a connection string within the ConnectionStrings section. The property takes precedence over this setting. A ConnectionStrings section might look like this:


            <qconfiguration>
            	<connectionStrings>
            		<add name="someDbConn" connectionString="Server=localhost;Database=SomeDb;Trusted_Connection=True" />
            	</connectionStrings>
            </configuration>

Which can be referenced by setting the ConnectionStringName to "someDbConn".

Gets or sets the type name of the connection that should be created.

The type name of the connection. The type name of the ADO.NET provider to use. The default is to use the OLE DB provider. Use the OLE DB Provider. This is the default value. System.Data.OleDb.OleDbConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Use the MS SQL Server Provider. System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Use the ODBC Provider.

Microsoft.Data.Odbc.OdbcConnection,Microsoft.Data.Odbc,version=1.0.3300.0,publicKeyToken=b77a5c561934e089,culture=neutral

This is an optional package that you can download from http://msdn.microsoft.com/downloads search for ODBC .NET Data Provider. Use the Oracle Provider.

System.Data.OracleClient.OracleConnection, System.Data.OracleClient, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

This is an optional package that you can download from http://msdn.microsoft.com/downloads search for .NET Managed Provider for Oracle.

Gets or sets the command text that is used to insert logging events into the database.

The command text used to insert logging events into the database. Either the text of the prepared statement or the name of the stored procedure to execute to write into the database. The property determines if this text is a prepared statement or a stored procedure.

Gets or sets the command type to execute.

The command type to execute. This value may be either (System.Data.CommandType.Text) to specify that the is a prepared statement to execute, or (System.Data.CommandType.StoredProcedure) to specify that the property is the name of a stored procedure to execute. The default value is (System.Data.CommandType.Text).

Should transactions be used to insert logging events in the database.

true if transactions should be used to insert logging events in the database, otherwise false. The default value is true. Gets or sets a value that indicates whether transactions should be used to insert logging events in the database. When set a single transaction will be used to insert the buffered events into the database. Otherwise each event will be inserted without using an explicit transaction.

Gets or sets the used to call the NetSend method.

The used to call the NetSend method. Unless a specified here for this appender the is queried for the security context to use. The default behavior is to use the security context of the current thread.

Should this appender try to reconnect to the database on error.

true if the appender should try to reconnect to the database after an error has occurred, otherwise false. The default value is false, i.e. not to try to reconnect. The default behaviour is for the appender not to try to reconnect to the database if an error occurs. Subsequent logging events are discarded. To force the appender to attempt to reconnect to the database set this property to true. When the appender attempts to connect to the database there may be a delay of up to the connection timeout specified in the connection string. This delay will block the calling application's thread. Until the connection can be reestablished this potential delay may occur multiple times.

Gets or sets the underlying .

The underlying . creates a to insert logging events into a database. Classes deriving from can use this property to get or set this . Use the underlying returned from if you require access beyond that which provides.

Parameter type used by the .

This class provides the basic database parameter properties as defined by the interface. This type can be subclassed to provide database specific functionality. The two methods that are called externally are and .

Initializes a new instance of the class.

Default constructor for the AdoNetAppenderParameter class.

Prepare the specified database command object.

The command to prepare. Prepares the database command object by adding this parameter to its collection of parameters.

Renders the logging event and set the parameter value in the command.

The command containing the parameter. The event to be rendered. Renders the logging event using this parameters layout object. Sets the value of the parameter on the command object.

The name of this parameter.

The database type for this parameter.

Flag to infer type rather than use the DbType

The precision for this parameter.

The scale for this parameter.

The size for this parameter.

The to use to render the logging event into an object for this parameter.

Gets or sets the name of this parameter.

The name of this parameter. The name of this parameter. The parameter name must match up to a named parameter to the SQL stored procedure or prepared statement.

Gets or sets the database type for this parameter.

The database type for this parameter. The database type for this parameter. This property should be set to the database type from the enumeration. See . This property is optional. If not specified the ADO.NET provider will attempt to infer the type from the value.

Gets or sets the precision for this parameter.

The precision for this parameter. The maximum number of digits used to represent the Value. This property is optional. If not specified the ADO.NET provider will attempt to infer the precision from the value.

Gets or sets the scale for this parameter.

The scale for this parameter. The number of decimal places to which Value is resolved. This property is optional. If not specified the ADO.NET provider will attempt to infer the scale from the value.

Gets or sets the size for this parameter.

The size for this parameter. The maximum size, in bytes, of the data within the column. This property is optional. If not specified the ADO.NET provider will attempt to infer the size from the value.

Gets or sets the to use to render the logging event into an object for this parameter.

The used to render the logging event into an object for this parameter. The that renders the value for this parameter. The can be used to adapt any into a for use in the property.

Adapter that extends and forwards all messages to an instance of .

Adapter that extends and forwards all messages to an instance of . Nicko Cadell

The writer to forward messages to

Create an instance of that forwards all messages to a .

The to forward to Create an instance of that forwards all messages to a .

Closes the writer and releases any system resources associated with the writer

Dispose this writer

flag indicating if we are being disposed Dispose this writer

Flushes any buffered output

Clears all buffers for the writer and causes any buffered data to be written to the underlying device

Writes a character to the wrapped TextWriter

the value to write to the TextWriter Writes a character to the wrapped TextWriter

Writes a character buffer to the wrapped TextWriter

the data buffer the start index the number of characters to write Writes a character buffer to the wrapped TextWriter

Writes a string to the wrapped TextWriter

the value to write to the TextWriter Writes a string to the wrapped TextWriter

Gets or sets the underlying .

The underlying . Gets or sets the underlying .

The Encoding in which the output is written

The The Encoding in which the output is written

Gets an object that controls formatting

The format provider Gets an object that controls formatting

Gets or sets the line terminator string used by the TextWriter

The line terminator to use Gets or sets the line terminator string used by the TextWriter

Utility class for system specific information.

Utility class of static methods for system specific information. Nicko Cadell Gert Driesen Alexey Solofnenko

Private constructor to prevent instances.

Only static methods are exposed from this type.

Initialize default values for private static fields.

Only static methods are exposed from this type.

Gets the assembly location path for the specified assembly.

The assembly to get the location for. The location of the assembly. This method does not guarantee to return the correct path to the assembly. If only tries to give an indication as to where the assembly was loaded from.

Gets the fully qualified name of the , including the name of the assembly from which the was loaded.

The to get the fully qualified name for. The fully qualified name for the . This is equivalent to the Type.AssemblyQualifiedName property, but this method works on the .NET Compact Framework 1.0 as well as the full .NET runtime.

Gets the short name of the .

The to get the name for. The short name of the . The short name of the assembly is the without the version, culture, or public key. i.e. it is just the assembly's file name without the extension. Use this rather than Assembly.GetName().Name because that is not available on the Compact Framework. Because of a FileIOPermission security demand we cannot do the obvious Assembly.GetName().Name. We are allowed to get the of the assembly so we start from there and strip out just the assembly name.

Gets the file name portion of the , including the extension.

The to get the file name for. The file name of the assembly. Gets the file name portion of the , including the extension.

Loads the type specified in the type string.

A sibling type to use to load the type. The name of the type to load. Flag set to true to throw an exception if the type cannot be loaded. true to ignore the case of the type name; otherwise, false The type loaded or null if it could not be loaded. If the type name is fully qualified, i.e. if contains an assembly name in the type name, the type will be loaded from the system using . If the type name is not fully qualified, it will be loaded from the assembly containing the specified relative type. If the type is not found in the assembly then all the loaded assemblies will be searched for the type.

Loads the type specified in the type string.

The name of the type to load. Flag set to true to throw an exception if the type cannot be loaded. true to ignore the case of the type name; otherwise, false The type loaded or null if it could not be loaded. If the type name is fully qualified, i.e. if contains an assembly name in the type name, the type will be loaded from the system using . If the type name is not fully qualified it will be loaded from the assembly that is directly calling this method. If the type is not found in the assembly then all the loaded assemblies will be searched for the type.

Loads the type specified in the type string.

An assembly to load the type from. The name of the type to load. Flag set to true to throw an exception if the type cannot be loaded. true to ignore the case of the type name; otherwise, false The type loaded or null if it could not be loaded. If the type name is fully qualified, i.e. if contains an assembly name in the type name, the type will be loaded from the system using . If the type name is not fully qualified it will be loaded from the specified assembly. If the type is not found in the assembly then all the loaded assemblies will be searched for the type.

Generate a new guid

A new Guid Generate a new guid

Create an

The name of the parameter that caused the exception The value of the argument that causes this exception The message that describes the error the ArgumentOutOfRangeException object Create a new instance of the class with a specified error message, the parameter name, and the value of the argument. The Compact Framework does not support the 3 parameter constructor for the type. This method provides an implementation that works for all platforms.

Parse a string into an value

the string to parse out param where the parsed value is placed true if the string was able to be parsed into an integer Attempts to parse the string into an integer. If the string cannot be parsed then this method returns false. The method does not throw an exception.

Parse a string into an value

Lookup an application setting

the application settings key to lookup the value for the key, or null Configuration APIs are not supported under the Compact Framework

Convert a path into a fully qualified local file path.

The path to convert. The fully qualified path. Converts the path specified to a fully qualified path. If the path is relative it is taken as relative from the application base directory. The path specified must be a local file path, a URI is not supported.

Creates a new case-insensitive instance of the class with the default initial capacity.

A new case-insensitive instance of the class with the default initial capacity The new Hashtable instance uses the default load factor, the CaseInsensitiveHashCodeProvider, and the CaseInsensitiveComparer.

Gets an empty array of types.

The Type.EmptyTypes field is not available on the .NET Compact Framework 1.0.

Cache the host name for the current machine

Cache the application friendly name

Text to output when a null is encountered.

Text to output when an unsupported feature is requested.

Start time for the current process.

Gets the system dependent line terminator.

The system dependent line terminator. Gets the system dependent line terminator.

Gets the base directory for this .

The base directory path for the current . Gets the base directory for this . The value returned may be either a local file path or a URI.

Gets the path to the configuration file for the current .

The path to the configuration file for the current . The .NET Compact Framework 1.0 does not have a concept of a configuration file. For this runtime, we use the entry assembly location as the root for the configuration file name. The value returned may be either a local file path or a URI.

Gets the path to the file that first executed in the current .

The path to the entry assembly. Gets the path to the file that first executed in the current .

Gets the ID of the current thread.

The ID of the current thread. On the .NET framework, the AppDomain.GetCurrentThreadId method is used to obtain the thread ID for the current thread. This is the operating system ID for the thread. On the .NET Compact Framework 1.0 it is not possible to get the operating system thread ID for the current thread. The native method GetCurrentThreadId is implemented inline in a header file and cannot be called. On the .NET Framework 2.0 the Thread.ManagedThreadId is used as this gives a stable id unrelated to the operating system thread ID which may change if the runtime is using fibers.

Get the host name or machine name for the current machine

The hostname or machine name Get the host name or machine name for the current machine The host name () or the machine name (Environment.MachineName) for the current machine, or if neither of these are available then NOT AVAILABLE is returned.

Get this application's friendly name

The friendly name of this application as a string If available the name of the application is retrieved from the AppDomain using AppDomain.CurrentDomain.FriendlyName. Otherwise the file name of the entry assembly is used.

Get the start time for the current process.

This is the time at which the log4net library was loaded into the AppDomain. Due to reports of a hang in the call to System.Diagnostics.Process.StartTime this is not the start time for the current process. The log4net library should be loaded by an application early during its startup, therefore this start time should be a good approximation for the actual start time. Note that AppDomains may be loaded and unloaded within the same process without the process terminating, however this start time will be set per AppDomain.

Text to output when a null is encountered.

Use this value to indicate a null has been encountered while outputting a string representation of an item. The default value is (null). This value can be overridden by specifying a value for the log4net.NullText appSetting in the application's .config file.

Text to output when an unsupported feature is requested.

Use this value when an unsupported feature is requested. The default value is NOT AVAILABLE. This value can be overridden by specifying a value for the log4net.NotAvailableText appSetting in the application's .config file.

A that ignores the message

This writer is used in special cases where it is necessary to protect a writer from being closed by a client. Nicko Cadell

Constructor

the writer to actually write to Create a new ProtectCloseTextWriter using a writer

Attach this instance to a different underlying

the writer to attach to Attach this instance to a different underlying

Does not close the underlying output writer.

Does not close the underlying output writer. This method does nothing.

Write the UTC date time to the output

Date pattern converter, uses a to format the current date and time in Universal time. See the for details on the date pattern syntax. Nicko Cadell

Write the current date to the output

Date pattern converter, uses a to format the current date and time to the writer as a string. The value of the determines the formatting of the date. The following values are allowed: Option value Output ISO8601 Uses the formatter. Formats using the "yyyy-MM-dd HH:mm:ss,fff" pattern. DATE Uses the formatter. Formats using the "dd MMM yyyy HH:mm:ss,fff" for example, "06 Nov 1994 15:49:37,459". ABSOLUTE Uses the formatter. Formats using the "HH:mm:ss,fff" for example, "15:49:37,459". other Any other pattern string uses the formatter. This formatter passes the pattern string to the method. For details on valid patterns see DateTimeFormatInfo Class. The date and time is in the local time zone and is rendered in that zone. To output the time in Universal time see . Nicko Cadell

The used to render the date to a string

Initialize the converter options

Write the current date to the output

that will receive the formatted result. null, state is not set Pass the current date and time to the for it to render it to the writer. The date and time passed is in the local time zone.

Write the current date and time to the output

that will receive the formatted result. null, state is not set Pass the current date and time to the for it to render it to the writer. The date is in Universal time when it is rendered.

Most of the work of the class is delegated to the PatternParser class.

The PatternParser processes a pattern string and returns a chain of objects. Nicko Cadell Gert Driesen

Constructor

The pattern to parse. Initializes a new instance of the class with the specified pattern string.

Parses the pattern into a chain of pattern converters.

The head of a chain of pattern converters. Parses the pattern into a chain of pattern converters.

Build the unified cache of converters from the static and instance maps

the list of all the converter names Build the unified cache of converters from the static and instance maps

Internal method to parse the specified pattern to find specified matches

the pattern to parse the converter names to match in the pattern The matches param must be sorted such that longer strings come before shorter ones.

Process a parsed literal

the literal text

Process a parsed converter pattern

the name of the converter the optional option for the converter the formatting info for the converter

Resets the internal state of the parser and adds the specified pattern converter to the chain.

The pattern converter to add.

The first pattern converter in the chain

the last pattern converter in the chain

The pattern

Internal map of converter identifiers to converter types

This map overrides the static s_globalRulesRegistry map.

Get the converter registry used by this parser

The converter registry used by this parser Get the converter registry used by this parser

Sort strings by length

that orders strings by string length. The longest strings are placed first

Used internally to accelerate hash table searches.

Internal class used to improve performance of string keyed hashtables. The hashcode of the string is cached for reuse. The string is stored as an interned value. When comparing two objects for equality the reference equality of the interned strings is compared. Nicko Cadell Gert Driesen

Construct key with string name

Initializes a new instance of the class with the specified name. Stores the hashcode of the string and interns the string key to optimize comparisons. The Compact Framework 1.0 the method does not work. On the Compact Framework the string keys are not interned nor are they compared by reference. The name of the logger.

Returns a hash code for the current instance.

A hash code for the current instance. Returns the cached hashcode.

Determines whether two instances are equal.

The to compare with the current . true if the specified is equal to the current ; otherwise, false. Compares the references of the interned strings.

Interface implemented by logger repository plugins.

Plugins define additional behavior that can be associated with a . The held by the property is used to store the plugins for a repository. The log4net.Config.PluginAttribute can be used to attach plugins to repositories created using configuration attributes. Nicko Cadell Gert Driesen

Attaches the plugin to the specified .

The that this plugin should be attached to. A plugin may only be attached to a single repository. This method is called when the plugin is attached to the repository.

Is called when the plugin is to shutdown.

This method is called to notify the plugin that it should stop operating and should detach from the repository.

Gets the name of the plugin.

The name of the plugin. Plugins are stored in the keyed by name. Each plugin instance attached to a repository must be a unique name.

Property pattern converter

Writes out the value of a named property. The property name should be set in the property. If the is set to null then all the properties are written as key value pairs. Nicko Cadell

Write the property value to the output

that will receive the formatted result. the event being logged Writes out the value of a named property. The property name should be set in the property. If the is set to null then all the properties are written as key value pairs.

Converter to output and truncate '.' separated strings

This abstract class supports truncating a '.' separated string to show a specified number of elements from the right hand side. This is used to truncate class names that are fully qualified. Subclasses should override the method to return the fully qualified string. Nicko Cadell

Initialize the converter

Get the fully qualified string data

the event being logged the fully qualified name Overridden by subclasses to get the fully qualified name before the precision is applied to it. Return the fully qualified '.' (dot/period) separated string.

Convert the pattern to the rendered message

that will receive the formatted result. the event being logged Render the to the precision specified by the property.

Date pattern converter, uses a to format the date of a .

Render the to the writer as a string. The value of the determines the formatting of the date. The following values are allowed: Option value Output ISO8601 Uses the formatter. Formats using the "yyyy-MM-dd HH:mm:ss,fff" pattern. DATE Uses the formatter. Formats using the "dd MMM yyyy HH:mm:ss,fff" for example, "06 Nov 1994 15:49:37,459". ABSOLUTE Uses the formatter. Formats using the "HH:mm:ss,yyyy" for example, "15:49:37,459". other Any other pattern string uses the formatter. This formatter passes the pattern string to the method. For details on valid patterns see DateTimeFormatInfo Class. The is in the local time zone and is rendered in that zone. To output the time in Universal time see . Nicko Cadell

The used to render the date to a string

Initialize the converter pattern based on the property.

Convert the pattern into the rendered message

that will receive the formatted result. the event being logged Pass the to the for it to render it to the writer. The passed is in the local time zone.

Appends logging events to the console.

ColoredConsoleAppender appends log events to the standard output stream or the error output stream using a layout specified by the user. It also allows the color of a specific type of message to be set. By default, all output is written to the console's standard output stream. The property can be set to direct the output to the error stream. NOTE: This appender writes directly to the application's attached console not to the System.Console.Out or System.Console.Error TextWriter. The System.Console.Out and System.Console.Error streams can be programmatically redirected (for example NUnit does this to capture program output). This appender will ignore these redirections because it needs to use Win32 API calls to colorize the output. To respect these redirections the must be used. When configuring the colored console appender, mapping should be specified to map a logging level to a color. For example:

The Level is the standard log4net logging level and ForeColor and BackColor can be any combination of the following values: Blue Green Red White Yellow Purple Cyan HighIntensity Rick Hobbs Nicko Cadell

The to use when writing to the Console standard output stream.

The to use when writing to the Console standard error output stream.

Initializes a new instance of the class.

The instance of the class is set up to write to the standard output stream.

Initializes a new instance of the class with the specified layout.

the layout to use for this appender The instance of the class is set up to write to the standard output stream.

Initializes a new instance of the class with the specified layout.

the layout to use for this appender flag set to true to write to the console error stream When is set to true, output is written to the standard error output stream. Otherwise, output is written to the standard output stream.

Add a mapping of level to color - done by the config file

The mapping to add Add a mapping to this appender. Each mapping defines the foreground and background colors for a level.

This method is called by the method.

The event to log. Writes the event to the console. The format of the output will depend on the appender's layout.

Initialize the options for this appender

Initialize the level to color mappings set on this appender.

Flag to write output to the error stream rather than the standard output stream

Mapping from level object to color value

The console output stream writer to write to

This writer is not thread safe.

Target is the value of the console output stream. This is either "Console.Out" or "Console.Error".

Target is the value of the console output stream. This is either "Console.Out" or "Console.Error". Target is the value of the console output stream. This is either "Console.Out" or "Console.Error".

This appender requires a to be set.

true This appender requires a to be set.

The enum of possible color values for use with the color mapping method

The following flags can be combined together to form the colors.

color is blue

color is green

color is red

color is white

color is yellow

color is purple

color is cyan

color is intensified

A class to act as a mapping between the level that a logging call is made at and the color it should be displayed as.

Defines the mapping between a level and the color it should be displayed in.

An entry in the

This is an abstract base class for types that are stored in the object. Nicko Cadell

Default protected constructor

Initialize any options defined on this entry

Should be overridden by any classes that need to initialise based on their options

The level that is the key for this mapping

The that is the key for this mapping Get or set the that is the key for this mapping subclass.

Initialize the options for the object

Combine the and together.

The mapped foreground color for the specified level

Required property. The mapped foreground color for the specified level.

The mapped background color for the specified level

Required property. The mapped background color for the specified level.

The combined and suitable for setting the console color.

Appends logging events to the terminal using ANSI color escape sequences.

AnsiColorTerminalAppender appends log events to the standard output stream or the error output stream using a layout specified by the user. It also allows the color of a specific level of message to be set. This appender expects the terminal to understand the VT100 control set in order to interpret the color codes. If the terminal or console does not understand the control codes the behavior is not defined. By default, all output is written to the console's standard output stream. The property can be set to direct the output to the error stream. NOTE: This appender writes each message to the System.Console.Out or System.Console.Error that is set at the time the event is appended. Therefore it is possible to programmatically redirect the output of this appender (for example NUnit does this to capture program output). While this is the desired behavior of this appender it may have security implications in your application. When configuring the ANSI colored terminal appender, a mapping should be specified to map a logging level to a color. For example:

The Level is the standard log4net logging level and ForeColor and BackColor can be any of the following values: Blue Green Red White Yellow Purple Cyan These color values cannot be combined together to make new colors. The attributes can be any combination of the following: Brightforeground is brighter Dimforeground is dimmer Underscoremessage is underlined Blinkforeground is blinking (does not work on all terminals) Reverseforeground and background are reversed Hiddenoutput is hidden Strikethroughmessage has a line through it While any of these attributes may be combined together not all combinations work well together, for example setting both Bright and Dim attributes makes no sense. Patrick Wagstrom Nicko Cadell

The to use when writing to the Console standard output stream.

The to use when writing to the Console standard error output stream.

Ansi code to reset terminal

Initializes a new instance of the class.

The instance of the class is set up to write to the standard output stream.

Add a mapping of level to color

The mapping to add Add a mapping to this appender. Each mapping defines the foreground and background colours for a level.

This method is called by the method.

The event to log. Writes the event to the console. The format of the output will depend on the appender's layout.

Initialize the options for this appender

Initialize the level to color mappings set on this appender.

Flag to write output to the error stream rather than the standard output stream

Mapping from level object to color value

Target is the value of the console output stream.

Target is the value of the console output stream. This is either "Console.Out" or "Console.Error". Target is the value of the console output stream. This is either "Console.Out" or "Console.Error".

This appender requires a to be set.

true This appender requires a to be set.

The enum of possible display attributes

The following flags can be combined together to form the ANSI color attributes.

text is bright

text is dim

text is underlined

text is blinking

Not all terminals support this attribute

text and background colors are reversed

text is hidden

text is displayed with a strikethrough

The enum of possible foreground or background color values for use with the color mapping method

The output can be in one for the following ANSI colors.

color is black

color is red

color is green

color is yellow

color is blue

color is magenta

color is cyan

color is white

A class to act as a mapping between the level that a logging call is made at and the color it should be displayed as.

Defines the mapping between a level and the color it should be displayed in.

Initialize the options for the object

Combine the and together and append the attributes.

The mapped foreground color for the specified level

Required property. The mapped foreground color for the specified level

The mapped background color for the specified level

Required property. The mapped background color for the specified level

The color attributes for the specified level

Required property. The color attributes for the specified level

The combined , and suitable for setting the ansi terminal color.

Convert between string and

Supports conversion from string to type, and from a type to a string. The string is used as the of the . Nicko Cadell

Interface supported by type converters

This interface supports conversion from a single type to arbitrary types. See . Nicko Cadell

Returns whether this converter can convert the object to the specified type

A Type that represents the type you want to convert to true if the conversion is possible Test if the type supported by this converter can be converted to the .

Converts the given value object to the specified type, using the arguments

the object to convert The Type to convert the value parameter to the converted object Converts the (which must be of the type supported by this converter) to the specified..

Can the target type be converted to the type supported by this object

A that represents the type you want to convert to true if the conversion is possible Returns true if the is assignable from a type.

Converts the given value object to the specified type, using the arguments

the object to convert The Type to convert the value parameter to the converted object Uses the method to convert the argument to a . The object cannot be converted to the . To check for this condition use the method.

Can the source type be converted to the type supported by this object

the type to convert true if the conversion is possible Returns true if the is the type.

Overrides the ConvertFrom method of IConvertFrom.

the object to convert to a PatternString the PatternString Creates and returns a new using the as the . The object cannot be converted to the target type. To check for this condition use the method.

Supports conversion from string to type.

Supports conversion from string to type. Nicko Cadell Gert Driesen

Can the source type be converted to the type supported by this object

the type to convert true if the conversion is possible Returns true if the is the type.

Overrides the ConvertFrom method of IConvertFrom.

the object to convert to an encoding the encoding Uses the method to convert the argument to an . The object cannot be converted to the target type. To check for this condition use the method.

Base class for Context Properties implementations

This class defines a basic property get set accessor Nicko Cadell

Gets or sets the value of a property

The value for the property with the specified key Gets or sets the value of a property

Map of repository plugins.

This class is a name keyed map of the plugins that are attached to a repository. Nicko Cadell Gert Driesen

Constructor

The repository that the plugins should be attached to. Initialize a new instance of the class with a repository that the plugins should be attached to.

Adds a to the map.

The to add to the map. The will be attached to the repository when added. If there already exists a plugin with the same name attached to the repository then the old plugin will be and replaced with the new plugin.

Removes a from the map.

The to remove from the map. Remove a specific plugin from this map.

Gets a by name.

The name of the to lookup. The from the map with the name specified, or null if no plugin is found. Lookup a plugin by name. If the plugin is not found null will be returned.

Gets all possible plugins as a list of objects.

All possible plugins as a list of objects. Get a collection of all the plugins defined in this map.

Abstract class that provides access to the HttpContext.Current that derived classes need.

This class handles the case when HttpContext.Current is null by writing SystemInfo.NotAvailableText to the writer. Ron Grabowski

Derived pattern converters must override this method in order to convert conversion specifiers in the correct way.

that will receive the formatted result. The on which the pattern converter should be executed. The under which the ASP.Net request is running.

Delegate used to handle creation of new wrappers.

The logger to wrap in a wrapper. Delegate used to handle creation of new wrappers. This delegate is called from the method to construct the wrapper for the specified logger. The delegate to use is supplied to the constructor.

Maps between logger objects and wrapper objects.

This class maintains a mapping between objects and objects. Use the method to lookup the for the specified . New wrapper instances are created by the method. The default behavior is for this method to delegate construction of the wrapper to the delegate supplied to the constructor. This allows specialization of the behavior without requiring subclassing of this type. Nicko Cadell Gert Driesen

Initializes a new instance of the

The handler to use to create the wrapper objects. Initializes a new instance of the class with the specified handler to create the wrapper objects.

Gets the wrapper object for the specified logger.

The wrapper object for the specified logger If the logger is null then the corresponding wrapper is null. Looks up the wrapper it it has previously been requested and returns it. If the wrapper has never been requested before then the virtual method is called.

Creates the wrapper object for the specified logger.

The logger to wrap in a wrapper. The wrapper object for the logger. This implementation uses the passed to the constructor to create the wrapper. This method can be overridden in a subclass.

Called when a monitored repository shutdown event is received.

The that is shutting down This method is called when a that this is holding loggers for has signaled its shutdown event . The default behavior of this method is to release the references to the loggers and their wrappers generated for this repository.

Event handler for repository shutdown event.

The sender of the event. The event args.

Map of logger repositories to hashtables of ILogger to ILoggerWrapper mappings

The handler to use to create the extension wrapper objects.

Internal reference to the delegate used to register for repository shutdown events.

Gets the map of logger repositories.

Map of logger repositories. Gets the hashtable that is keyed on . The values are hashtables keyed on with the value being the corresponding .

Static manager that controls the creation of repositories

Static manager that controls the creation of repositories This class is used by the wrapper managers (e.g. ) to provide access to the objects. This manager also holds the that is used to lookup and create repositories. The selector can be set either programmatically using the property, or by setting the log4net.RepositorySelector AppSetting in the applications config file to the fully qualified type name of the selector to use. Nicko Cadell Gert Driesen

Private constructor to prevent instances. Only static methods should be used.

Hook the shutdown event

On the full .NET runtime, the static constructor hooks up the AppDomain.ProcessExit and AppDomain.DomainUnload> events. These are used to shutdown the log4net system as the application exits.

This needs to be in a separate method because the events make a LinkDemand for the ControlAppDomain SecurityPermission. Because this is a LinkDemand it is demanded at JIT time. Therefore we cannot catch the exception in the method itself, we have to catch it in the caller.

Return the default instance.

the repository to lookup in Return the default instance Gets the for the repository specified by the argument.

Returns the default instance.

The assembly to use to lookup the repository. The default instance.

Return the default instance.

the repository to lookup in Return the default instance Gets the for the repository specified by the argument.

Returns the default instance.

The assembly to use to lookup the repository. The default instance. Returns the default instance.

Returns the named logger if it exists.

The repository to lookup in. The fully qualified logger name to look for. The logger found, or null if the named logger does not exist in the specified repository. If the named logger exists (in the specified repository) then it returns a reference to the logger, otherwise it returns null.

Returns the named logger if it exists.

The assembly to use to lookup the repository. The fully qualified logger name to look for. The logger found, or null if the named logger does not exist in the specified assembly's repository. If the named logger exists (in the specified assembly's repository) then it returns a reference to the logger, otherwise it returns null.

Returns all the currently defined loggers in the specified repository.

The repository to lookup in. All the defined loggers. The root logger is not included in the returned array.

Returns all the currently defined loggers in the specified assembly's repository.

The assembly to use to lookup the repository. All the defined loggers. The root logger is not included in the returned array.

Retrieves or creates a named logger.

The repository to lookup in. The name of the logger to retrieve. The logger with the name specified. Retrieves a logger named as the parameter. If the named logger already exists, then the existing instance will be returned. Otherwise, a new instance is created. By default, loggers do not have a set level but inherit it from the hierarchy. This is one of the central features of log4net.

Retrieves or creates a named logger.

The assembly to use to lookup the repository. The name of the logger to retrieve. The logger with the name specified. Retrieves a logger named as the parameter. If the named logger already exists, then the existing instance will be returned. Otherwise, a new instance is created. By default, loggers do not have a set level but inherit it from the hierarchy. This is one of the central features of log4net.

Shorthand for .

The repository to lookup in. The of which the fullname will be used as the name of the logger to retrieve. The logger with the name specified. Gets the logger for the fully qualified name of the type specified.

Shorthand for .

the assembly to use to lookup the repository The of which the fullname will be used as the name of the logger to retrieve. The logger with the name specified. Gets the logger for the fully qualified name of the type specified.

Shuts down the log4net system.

Calling this method will safely close and remove all appenders in all the loggers including root contained in all the default repositories. Some appenders need to be closed before the application exists. Otherwise, pending logging events might be lost. The shutdown method is careful to close nested appenders before closing regular appenders. This is allows configurations where a regular appender is attached to a logger and again to a nested appender.

Shuts down the repository for the repository specified.

The repository to shutdown. Calling this method will safely close and remove all appenders in all the loggers including root contained in the repository for the specified. Some appenders need to be closed before the application exists. Otherwise, pending logging events might be lost. The shutdown method is careful to close nested appenders before closing regular appenders. This is allows configurations where a regular appender is attached to a logger and again to a nested appender.

Shuts down the repository for the repository specified.

The assembly to use to lookup the repository. Calling this method will safely close and remove all appenders in all the loggers including root contained in the repository for the repository. The repository is looked up using the specified. Some appenders need to be closed before the application exists. Otherwise, pending logging events might be lost. The shutdown method is careful to close nested appenders before closing regular appenders. This is allows configurations where a regular appender is attached to a logger and again to a nested appender.

Resets all values contained in this repository instance to their defaults.

The repository to reset. Resets all values contained in the repository instance to their defaults. This removes all appenders from all loggers, sets the level of all non-root loggers to null, sets their additivity flag to true and sets the level of the root logger to . Moreover, message disabling is set its default "off" value.

Resets all values contained in this repository instance to their defaults.

The assembly to use to lookup the repository to reset. Resets all values contained in the repository instance to their defaults. This removes all appenders from all loggers, sets the level of all non-root loggers to null, sets their additivity flag to true and sets the level of the root logger to . Moreover, message disabling is set its default "off" value.

Creates a repository with the specified name.

The name of the repository, this must be unique amongst repositories. The created for the repository. CreateDomain is obsolete. Use CreateRepository instead of CreateDomain. Creates the default type of which is a object. The name must be unique. Repositories cannot be redefined. An will be thrown if the repository already exists. The specified repository already exists.

Creates a repository with the specified name.

The name of the repository, this must be unique amongst repositories. The created for the repository. Creates the default type of which is a object. The name must be unique. Repositories cannot be redefined. An will be thrown if the repository already exists. The specified repository already exists.

Creates a repository with the specified name and repository type.

The name of the repository, this must be unique to the repository. A that implements and has a no arg constructor. An instance of this type will be created to act as the for the repository specified. The created for the repository. CreateDomain is obsolete. Use CreateRepository instead of CreateDomain. The name must be unique. Repositories cannot be redefined. An Exception will be thrown if the repository already exists. The specified repository already exists.

Creates a repository with the specified name and repository type.

The name of the repository, this must be unique to the repository. A that implements and has a no arg constructor. An instance of this type will be created to act as the for the repository specified. The created for the repository. The name must be unique. Repositories cannot be redefined. An Exception will be thrown if the repository already exists. The specified repository already exists.

Creates a repository for the specified assembly and repository type.

The assembly to use to get the name of the repository. A that implements and has a no arg constructor. An instance of this type will be created to act as the for the repository specified. The created for the repository. CreateDomain is obsolete. Use CreateRepository instead of CreateDomain. The created will be associated with the repository specified such that a call to with the same assembly specified will return the same repository instance.

Creates a repository for the specified assembly and repository type.

The assembly to use to get the name of the repository. A that implements and has a no arg constructor. An instance of this type will be created to act as the for the repository specified. The created for the repository. The created will be associated with the repository specified such that a call to with the same assembly specified will return the same repository instance.

Gets an array of all currently defined repositories.

An array of all the known objects. Gets an array of all currently defined repositories.

Internal method to get pertinent version info.

A string of version info.

Called when the event fires

the that is exiting null Called when the event fires. When the event is triggered the log4net system is .

Called when the event fires

the that is exiting null Called when the event fires. When the event is triggered the log4net system is .

Initialize the default repository selector

Gets or sets the repository selector used by the .

The repository selector used by the . The repository selector () is used by the to create and select repositories (). The caller to supplies either a string name or an assembly (if not supplied the assembly is inferred using ). This context is used by the selector to lookup a specific repository. For the full .NET Framework, the default repository is DefaultRepositorySelector; for the .NET Compact Framework CompactRepositorySelector is the default repository.

Stores logging events in an array.

The memory appender stores all the logging events that are appended in an in-memory array. Use the method to get the current list of events that have been appended. Use the method to clear the current list of events. Julian Biddle Nicko Cadell Gert Driesen

Initializes a new instance of the class.

Default constructor.

Gets the events that have been logged.

The events that have been logged Gets the events that have been logged.

This method is called by the method.

the event to log Stores the in the events list.

Clear the list of events

The list of events that have been appended.

Value indicating which fields in the event should be fixed

By default all fields are fixed

Gets or sets a value indicating whether only part of the logging event data should be fixed.

true if the appender should only fix part of the logging event data, otherwise false. The default is false. Setting this property to true will cause only part of the event data to be fixed and stored in the appender, hereby improving performance. See for more information.

Gets or sets the fields that will be fixed in the event

The logging event needs to have certain thread specific values captured before it can be buffered. See for details.

Write the current threads username to the output

Write the current threads username to the output writer Nicko Cadell

Write the current threads username to the output

the writer to write to null, state is not set Write the current threads username to the output .

An always empty .

A singleton implementation of the interface that always represents an empty collection. Nicko Cadell Gert Driesen

Initializes a new instance of the class.

Uses a private access modifier to enforce the singleton pattern.

Copies the elements of the to an , starting at a particular Array index.

The one-dimensional that is the destination of the elements copied from . The Array must have zero-based indexing. The zero-based index in array at which copying begins. As the collection is empty no values are copied into the array.

Returns an enumerator that can iterate through a collection.

An that can be used to iterate through the collection. As the collection is empty a is returned.

The singleton instance of the empty collection.

Gets the singleton instance of the empty collection.

The singleton instance of the empty collection. Gets the singleton instance of the empty collection.

Gets a value indicating if access to the is synchronized (thread-safe).

true if access to the is synchronized (thread-safe); otherwise, false. For the this property is always true.

Gets the number of elements contained in the .

The number of elements contained in the . As the collection is empty the is always 0.

Gets an object that can be used to synchronize access to the .

An object that can be used to synchronize access to the . As the collection is empty and thread safe and synchronized this instance is also the object.

This class is used by client applications to request logger instances.

This class has static methods that are used by a client to request a logger instance. The method is used to retrieve a logger. See the interface for more details. Simple example of logging messages


            ILog log = LogManager.GetLogger("application-log");
            
            log.Info("Application Start");
            log.Debug("This is a debug message");
            
            if (log.IsDebugEnabled)
            {
            	log.Debug("This is another debug message");
            }

Nicko Cadell Gert Driesen

Initializes a new instance of the class.

Uses a private access modifier to prevent instantiation of this class. Returns the named logger if it exists.

Returns the named logger if it exists.

If the named logger exists (in the default repository) then it returns a reference to the logger, otherwise it returns null. The fully qualified logger name to look for. The logger found, or null if no logger could be found.

Returns the named logger if it exists.

If the named logger exists (in the specified repository) then it returns a reference to the logger, otherwise it returns null. The repository to lookup in. The fully qualified logger name to look for. The logger found, or null if the logger doesn't exist in the specified repository.

Returns the named logger if it exists.

If the named logger exists (in the repository for the specified assembly) then it returns a reference to the logger, otherwise it returns null. The assembly to use to lookup the repository. The fully qualified logger name to look for. The logger, or null if the logger doesn't exist in the specified assembly's repository. Get the currently defined loggers.

Returns all the currently defined loggers in the default repository.

The root logger is not included in the returned array. All the defined loggers.

Returns all the currently defined loggers in the specified repository.

The repository to lookup in. The root logger is not included in the returned array. All the defined loggers.

Returns all the currently defined loggers in the specified assembly's repository.

The assembly to use to lookup the repository. The root logger is not included in the returned array. All the defined loggers. Get or create a logger.

Retrieves or creates a named logger.

Retrieves a logger named as the parameter. If the named logger already exists, then the existing instance will be returned. Otherwise, a new instance is created. By default, loggers do not have a set level but inherit it from the hierarchy. This is one of the central features of log4net. The name of the logger to retrieve. The logger with the name specified.

Retrieves or creates a named logger.

Retrieve a logger named as the parameter. If the named logger already exists, then the existing instance will be returned. Otherwise, a new instance is created. By default, loggers do not have a set level but inherit it from the hierarchy. This is one of the central features of log4net. The repository to lookup in. The name of the logger to retrieve. The logger with the name specified.

Retrieves or creates a named logger.

Retrieve a logger named as the parameter. If the named logger already exists, then the existing instance will be returned. Otherwise, a new instance is created. By default, loggers do not have a set level but inherit it from the hierarchy. This is one of the central features of log4net. The assembly to use to lookup the repository. The name of the logger to retrieve. The logger with the name specified.

Shorthand for .

Get the logger for the fully qualified name of the type specified. The full name of will be used as the name of the logger to retrieve. The logger with the name specified.

Shorthand for .

Gets the logger for the fully qualified name of the type specified. The repository to lookup in. The full name of will be used as the name of the logger to retrieve. The logger with the name specified.

Shorthand for .

Gets the logger for the fully qualified name of the type specified. The assembly to use to lookup the repository. The full name of will be used as the name of the logger to retrieve. The logger with the name specified.

Shuts down the log4net system.

Shuts down the default repository.

Calling this method will safely close and remove all appenders in all the loggers including root contained in the default repository. Some appenders need to be closed before the application exists. Otherwise, pending logging events might be lost. The shutdown method is careful to close nested appenders before closing regular appenders. This is allows configurations where a regular appender is attached to a logger and again to a nested appender.

Shuts down the repository for the repository specified.

Calling this method will safely close and remove all appenders in all the loggers including root contained in the specified. Some appenders need to be closed before the application exists. Otherwise, pending logging events might be lost. The shutdown method is careful to close nested appenders before closing regular appenders. This is allows configurations where a regular appender is attached to a logger and again to a nested appender. The repository to shutdown.

Shuts down the repository specified.

Calling this method will safely close and remove all appenders in all the loggers including root contained in the repository. The repository is looked up using the specified. Some appenders need to be closed before the application exists. Otherwise, pending logging events might be lost. The shutdown method is careful to close nested appenders before closing regular appenders. This is allows configurations where a regular appender is attached to a logger and again to a nested appender. The assembly to use to lookup the repository. Reset the configuration of a repository

Resets all values contained in this repository instance to their defaults.

Resets all values contained in the repository instance to their defaults. This removes all appenders from all loggers, sets the level of all non-root loggers to null, sets their additivity flag to true and sets the level of the root logger to . Moreover, message disabling is set to its default "off" value.

Resets all values contained in this repository instance to their defaults.

Reset all values contained in the repository instance to their defaults. This removes all appenders from all loggers, sets the level of all non-root loggers to null, sets their additivity flag to true and sets the level of the root logger to . Moreover, message disabling is set to its default "off" value. The repository to reset.

Resets all values contained in this repository instance to their defaults.

Returns the default instance.

Gets the for the repository specified by the callers assembly (). The instance for the default repository.

Returns the default instance.

The default instance. Gets the for the repository specified by the argument. The repository to lookup in.

Returns the default instance.

The default instance. Gets the for the repository specified by the argument. The assembly to use to lookup the repository. Get a logger repository.

Returns the default instance.

Gets the for the repository specified by the callers assembly (). The instance for the default repository.

Returns the default instance.

The default instance. Gets the for the repository specified by the argument. The repository to lookup in.

Returns the default instance.

The default instance. Gets the for the repository specified by the argument. The assembly to use to lookup the repository. Create a domain

Creates a repository with the specified repository type.

CreateDomain is obsolete. Use CreateRepository instead of CreateDomain. The created will be associated with the repository specified such that a call to will return the same repository instance. A that implements and has a no arg constructor. An instance of this type will be created to act as the for the repository specified. The created for the repository. Create a logger repository.

Creates a repository with the specified repository type.

A that implements and has a no arg constructor. An instance of this type will be created to act as the for the repository specified. The created for the repository. The created will be associated with the repository specified such that a call to will return the same repository instance.

Creates a repository with the specified name.

CreateDomain is obsolete. Use CreateRepository instead of CreateDomain. Creates the default type of which is a object. The name must be unique. Repositories cannot be redefined. An will be thrown if the repository already exists. The name of the repository, this must be unique amongst repositories. The created for the repository. The specified repository already exists.

Creates a repository with the specified name.

Creates the default type of which is a object. The name must be unique. Repositories cannot be redefined. An will be thrown if the repository already exists. The name of the repository, this must be unique amongst repositories. The created for the repository. The specified repository already exists.

Creates a repository with the specified name and repository type.

CreateDomain is obsolete. Use CreateRepository instead of CreateDomain. The name must be unique. Repositories cannot be redefined. An will be thrown if the repository already exists. The name of the repository, this must be unique to the repository. A that implements and has a no arg constructor. An instance of this type will be created to act as the for the repository specified. The created for the repository. The specified repository already exists.

Creates a repository with the specified name and repository type.

The name must be unique. Repositories cannot be redefined. An will be thrown if the repository already exists. The name of the repository, this must be unique to the repository. A that implements and has a no arg constructor. An instance of this type will be created to act as the for the repository specified. The created for the repository. The specified repository already exists.

Creates a repository for the specified assembly and repository type.

CreateDomain is obsolete. Use CreateRepository instead of CreateDomain. The created will be associated with the repository specified such that a call to with the same assembly specified will return the same repository instance. The assembly to use to get the name of the repository. A that implements and has a no arg constructor. An instance of this type will be created to act as the for the repository specified. The created for the repository.

Creates a repository for the specified assembly and repository type.

The created will be associated with the repository specified such that a call to with the same assembly specified will return the same repository instance. The assembly to use to get the name of the repository. A that implements and has a no arg constructor. An instance of this type will be created to act as the for the repository specified. The created for the repository.

Gets the list of currently defined repositories.

Get an array of all the objects that have been created. An array of all the known objects.

Looks up the wrapper object for the logger specified.

The logger to get the wrapper for. The wrapper for the logger specified.

Looks up the wrapper objects for the loggers specified.

The loggers to get the wrappers for. The wrapper objects for the loggers specified.

Create the objects used by this manager.

The logger to wrap. The wrapper for the logger specified.

The wrapper map to use to hold the objects.

Extract the date from the

Extract the date from the Nicko Cadell Gert Driesen

Interface for raw layout objects

Interface used to format a to an object. This interface should not be confused with the interface. This interface is used in only certain specialized situations where a raw object is required rather than a formatted string. The is not generally useful than this interface. Nicko Cadell Gert Driesen

Implement this method to create your own layout format.

The event to format returns the formatted event Implement this method to create your own layout format.

Constructs a RawTimeStampLayout

Gets the as a .

The event to format returns the time stamp Gets the as a . The time stamp is in local time. To format the time stamp in universal time use .

Defines the default set of levels recognized by the system.

Each has an associated . Levels have a numeric that defines the relative ordering between levels. Two Levels with the same are deemed to be equivalent. The levels that are recognized by log4net are set for each and each repository can have different levels defined. The levels are stored in the on the repository. Levels are looked up by name from the . When logging at level INFO the actual level used is not but the value of LoggerRepository.LevelMap["INFO"]. The default value for this is , but this can be changed by reconfiguring the level map. Each level has a in addition to its . The is the string that is written into the output log. By default the display name is the same as the level name, but this can be used to alias levels or to localize the log output. Some of the predefined levels recognized by the system are: . . . . . . . Nicko Cadell Gert Driesen

Constructor

Integer value for this level, higher values represent more severe levels. The string name of this level. The display name for this level. This may be localized or otherwise different from the name Initializes a new instance of the class with the specified level name and value.

Constructor

Integer value for this level, higher values represent more severe levels. The string name of this level. Initializes a new instance of the class with the specified level name and value.

Returns the representation of the current .

A representation of the current . Returns the level .

Compares levels.

The object to compare against. true if the objects are equal. Compares the levels of instances, and defers to base class if the target object is not a instance.

Returns a hash code

A hash code for the current . Returns a hash code suitable for use in hashing algorithms and data structures like a hash table. Returns the hash code of the level .

Compares this instance to a specified object and returns an indication of their relative values.

A instance or to compare with this instance. A 32-bit signed integer that indicates the relative order of the values compared. The return value has these meanings: Value Meaning Less than zero This instance is less than . Zero This instance is equal to . Greater than zero This instance is greater than . -or- is . must be an instance of or ; otherwise, an exception is thrown. is not a .

Returns a value indicating whether a specified is greater than another specified .

A A true if is greater than ; otherwise, false. Compares two levels.

Returns a value indicating whether a specified is less than another specified .

A A true if is less than ; otherwise, false. Compares two levels.

Returns a value indicating whether a specified is greater than or equal to another specified .

A A true if is greater than or equal to ; otherwise, false. Compares two levels.

Returns a value indicating whether a specified is less than or equal to another specified .

A A true if is less than or equal to ; otherwise, false. Compares two levels.

Returns a value indicating whether two specified objects have the same value.

A or . A or . true if the value of is the same as the value of ; otherwise, false. Compares two levels.

Returns a value indicating whether two specified objects have different values.

A or . A or . true if the value of is different from the value of ; otherwise, false. Compares two levels.

Compares two specified instances.

The first to compare. The second to compare. A 32-bit signed integer that indicates the relative order of the two values compared. The return value has these meanings: Value Meaning Less than zero is less than . Zero is equal to . Greater than zero is greater than . Compares two levels.

The level designates a higher level than all the rest.

The level designates very severe error events. System unusable, emergencies.

The level designates very severe error events that will presumably lead the application to abort.

The level designates very severe error events. Take immediate action, alerts.

The level designates very severe error events. Critical condition, critical.

The level designates very severe error events.

The level designates error events that might still allow the application to continue running.

The level designates potentially harmful situations.

The level designates informational messages that highlight the progress of the application at the highest level.

The level designates informational messages that highlight the progress of the application at coarse-grained level.

The level designates fine-grained informational events that are most useful to debug an application.

The level designates the lowest level possible.

Gets the name of this level.

The name of this level. Gets the name of this level.

Gets the value of this level.

The value of this level. Gets the value of this level.

Gets the display name of this level.

The display name of this level. Gets the display name of this level.

Assembly level attribute to configure the .

This attribute may only be used at the assembly scope and can only be used once per assembly. Use this attribute to configure the without calling one of the methods. If neither of the or properties are set the configuration is loaded from the application's .config file. If set the property takes priority over the property. The property specifies a path to a file to load the config from. The path is relative to the application's base directory; . The property is used as a postfix to the assembly file name. The config file must be located in the application's base directory; . For example in a console application setting the to config has the same effect as not specifying the or properties. The property can be set to cause the to watch the configuration file for changes. Log4net will only look for assembly level configuration attributes once. When using the log4net assembly level attributes to control the configuration of log4net you must ensure that the first call to any of the methods is made from the assembly with the configuration attributes. If you cannot guarantee the order in which log4net calls will be made from different assemblies you must use programmatic configuration instead, i.e. call the method directly. Nicko Cadell Gert Driesen

Base class for all log4net configuration attributes.

This is an abstract class that must be extended by specific configurators. This attribute allows the configurator to be parameterized by an assembly level attribute. Nicko Cadell Gert Driesen

Constructor used by subclasses.

the ordering priority for this configurator The is used to order the configurator attributes before they are invoked. Higher priority configurators are executed before lower priority ones.

Configures the for the specified assembly.

The assembly that this attribute was defined on. The repository to configure. Abstract method implemented by a subclass. When this method is called the subclass should configure the .

Compare this instance to another ConfiguratorAttribute

the object to compare to see Compares the priorities of the two instances. Sorts by priority in descending order. Objects with the same priority are randomly ordered.

Default constructor

Configures the for the specified assembly.

The assembly that this attribute was defined on. The repository to configure. Configure the repository using the . The specified must extend the class otherwise the will not be able to configure it. The does not extend .

Attempt to load configuration from the local file system

The assembly that this attribute was defined on. The repository to configure.

Configure the specified repository using a

The repository to configure. the FileInfo pointing to the config file

Attempt to load configuration from a URI

The assembly that this attribute was defined on. The repository to configure.

Gets or sets the filename of the configuration file.

The filename of the configuration file. If specified, this is the name of the configuration file to use with the . This file path is relative to the application base directory (). The takes priority over the .

Gets or sets the extension of the configuration file.

The extension of the configuration file. If specified this is the extension for the configuration file. The path to the config file is built by using the application base directory (), the assembly file name and the config file extension. If the is set to MyExt then possible config file names would be: MyConsoleApp.exe.MyExt or MyClassLibrary.dll.MyExt. The takes priority over the .

Gets or sets a value indicating whether to watch the configuration file.

true if the configuration should be watched, false otherwise. If this flag is specified and set to true then the framework will watch the configuration file and will reload the config each time the file is modified. The config file can only be watched if it is loaded from local disk. In a No-Touch (Smart Client) deployment where the application is downloaded from a web server the config file may not reside on the local disk and therefore it may not be able to watch it. Watching configuration is not supported on the SSCLI.

Delivers logging events to a remote logging sink.

This Appender is designed to deliver events to a remote sink. That is any object that implements the interface. It delivers the events using .NET remoting. The object to deliver events to is specified by setting the appenders property. The RemotingAppender buffers events before sending them. This allows it to make more efficient use of the remoting infrastructure. Once the buffer is full the events are still not sent immediately. They are scheduled to be sent using a pool thread. The effect is that the send occurs asynchronously. This is very important for a number of non obvious reasons. The remoting infrastructure will flow thread local variables (stored in the ), if they are marked as , across the remoting boundary. If the server is not contactable then the remoting infrastructure will clear the objects from the . To prevent a logging failure from having side effects on the calling application the remoting call must be made from a separate thread to the one used by the application. A thread is used for this. If no thread is available then the events will block in the thread pool manager until a thread is available. Because the events are sent asynchronously using pool threads it is possible to close this appender before all the queued events have been sent. When closing the appender attempts to wait until all the queued events have been sent, but this will timeout after 30 seconds regardless. If this appender is being closed because the event has fired it may not be possible to send all the queued events. During process exit the runtime limits the time that a event handler is allowed to run for. If the runtime terminates the threads before the queued events have been sent then they will be lost. To ensure that all events are sent the appender must be closed before the application exits. See for details on how to shutdown log4net programmatically. Nicko Cadell Gert Driesen Daniel Cazzulino

Initializes a new instance of the class.

Default constructor.

Initialize the appender based on the options set

Send the contents of the buffer to the remote sink.

The events are not sent immediately. They are scheduled to be sent using a pool thread. The effect is that the send occurs asynchronously. This is very important for a number of non obvious reasons. The remoting infrastructure will flow thread local variables (stored in the ), if they are marked as , across the remoting boundary. If the server is not contactable then the remoting infrastructure will clear the objects from the . To prevent a logging failure from having side effects on the calling application the remoting call must be made from a separate thread to the one used by the application. A thread is used for this. If no thread is available then the events will block in the thread pool manager until a thread is available. The events to send.

Override base class close.

This method waits while there are queued work items. The events are sent asynchronously using work items. These items will be sent once a thread pool thread is available to send them, therefore it is possible to close the appender before all the queued events have been sent. This method attempts to wait until all the queued events have been sent, but this method will timeout after 30 seconds regardless. If the appender is being closed because the event has fired it may not be possible to send all the queued events. During process exit the runtime limits the time that a event handler is allowed to run for.

A work item is being queued into the thread pool

A work item from the thread pool has completed

Send the contents of the buffer to the remote sink.

This method is designed to be used with the . This method expects to be passed an array of objects in the state param. the logging events to send

The URL of the remote sink.

The local proxy (.NET remoting) for the remote logging sink.

The number of queued callbacks currently waiting or executing

Event used to signal when there are no queued work items

This event is set when there are no queued work items. In this state it is safe to close the appender.

Gets or sets the URL of the well-known object that will accept the logging events.

The well-known URL of the remote sink. The URL of the remoting sink that will accept logging events. The sink must implement the interface.

Interface used to deliver objects to a remote sink.

This interface must be implemented by a remoting sink if the is to be used to deliver logging events to the sink.

Delivers logging events to the remote sink

Array of events to log. Delivers logging events to the remote sink

Logs events to a remote syslog daemon.

The BSD syslog protocol is used to remotely log to a syslog daemon. The syslogd listens for for messages on UDP port 514. The syslog UDP protocol is not authenticated. Most syslog daemons do not accept remote log messages because of the security implications. You may be able to use the LocalSyslogAppender to talk to a local syslog service. There is an RFC 3164 that claims to document the BSD Syslog Protocol. This RFC can be seen here: http://www.faqs.org/rfcs/rfc3164.html. This appender generates what the RFC calls an "Original Device Message", i.e. does not include the TIMESTAMP or HOSTNAME fields. By observation this format of message will be accepted by all current syslog daemon implementations. The daemon will attach the current time and the source hostname or IP address to any messages received. Syslog messages must have a facility and and a severity. The severity is derived from the Level of the logging event. The facility must be chosen from the set of defined syslog values. The facilities list is predefined and cannot be extended. An identifier is specified with each log message. This can be specified by setting the property. The identity (also know as the tag) must not contain white space. The default value for the identity is the application name (from ). Rob Lyon Nicko Cadell

Sends logging events as connectionless UDP datagrams to a remote host or a multicast group using an .

UDP guarantees neither that messages arrive, nor that they arrive in the correct order. To view the logging results, a custom application can be developed that listens for logging events. When decoding events send via this appender remember to use the same encoding to decode the events as was used to send the events. See the property to specify the encoding to use. This example shows how to log receive logging events that are sent on IP address 244.0.0.1 and port 8080 to the console. The event is encoded in the packet as a unicode string and it is decoded as such.


             IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
             UdpClient udpClient;
             byte[] buffer;
             string loggingEvent;
             
             try 
             {
                 udpClient = new UdpClient(8080);
                 
                 while(true) 
                 {
                     buffer = udpClient.Receive(ref remoteEndPoint);
                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer);
                     Console.WriteLine(loggingEvent);
                 }
             } 
             catch(Exception e) 
             {
                 Console.WriteLine(e.ToString());
             }


             Dim remoteEndPoint as IPEndPoint
             Dim udpClient as UdpClient
             Dim buffer as Byte()
             Dim loggingEvent as String
             
             Try 
                 remoteEndPoint = new IPEndPoint(IPAddress.Any, 0)
                 udpClient = new UdpClient(8080)
            
                 While True
                     buffer = udpClient.Receive(ByRef remoteEndPoint)
                     loggingEvent = System.Text.Encoding.Unicode.GetString(buffer)
                     Console.WriteLine(loggingEvent)
                 Wend
             Catch e As Exception
                 Console.WriteLine(e.ToString())
             End Try

An example configuration section to log information using this appender to the IP 224.0.0.1 on port 8080:

Gert Driesen Nicko Cadell

Initializes a new instance of the class.

The default constructor initializes all fields to their default values.

Initialize the appender based on the options set.

This is part of the delayed object activation scheme. The method must be called on this object after the configuration properties have been set. Until is called this object is in an undefined state and must not be used. If any of the configuration properties are modified then must be called again. The appender will be ignored if no was specified or an invalid remote or local TCP port number was specified. The required property was not specified. The TCP port number assigned to or is less than or greater than .

This method is called by the method.

The event to log. Sends the event using an UDP datagram. Exceptions are passed to the .

Closes the UDP connection and releases all resources associated with this instance.

Disables the underlying and releases all managed and unmanaged resources associated with the .

Initializes the underlying connection.

The underlying is initialized and binds to the port number from which you intend to communicate. Exceptions are passed to the .

The IP address of the remote host or multicast group to which the logging event will be sent.

The TCP port number of the remote host or multicast group to which the logging event will be sent.

The cached remote endpoint to which the logging events will be sent.

The TCP port number from which the will communicate.

The instance that will be used for sending the logging events.

The encoding to use for the packet.

Gets or sets the IP address of the remote host or multicast group to which the underlying should sent the logging event.

The IP address of the remote host or multicast group to which the logging event will be sent. Multicast addresses are identified by IP class D addresses (in the range 224.0.0.0 to 239.255.255.255). Multicast packets can pass across different networks through routers, so it is possible to use multicasts in an Internet scenario as long as your network provider supports multicasting. Hosts that want to receive particular multicast messages must register their interest by joining the multicast group. Multicast messages are not sent to networks where no host has joined the multicast group. Class D IP addresses are used for multicast groups, to differentiate them from normal host addresses, allowing nodes to easily detect if a message is of interest. Static multicast addresses that are needed globally are assigned by IANA. A few examples are listed in the table below: IP Address Description 224.0.0.1 Sends a message to all system on the subnet. 224.0.0.2 Sends a message to all routers on the subnet. 224.0.0.12 The DHCP server answers messages on the IP address 224.0.0.12, but only on a subnet. A complete list of actually reserved multicast addresses and their owners in the ranges defined by RFC 3171 can be found at the IANA web site. The address range 239.0.0.0 to 239.255.255.255 is reserved for administrative scope-relative addresses. These addresses can be reused with other local groups. Routers are typically configured with filters to prevent multicast traffic in this range from flowing outside of the local network.

Gets or sets the TCP port number of the remote host or multicast group to which the underlying should sent the logging event.

An integer value in the range to indicating the TCP port number of the remote host or multicast group to which the logging event will be sent. The underlying will send messages to this TCP port number on the remote host or multicast group. The value specified is less than or greater than .

Gets or sets the TCP port number from which the underlying will communicate.

An integer value in the range to indicating the TCP port number from which the underlying will communicate. The underlying will bind to this port for sending messages. Setting the value to 0 (the default) will cause the udp client not to bind to a local port. The value specified is less than or greater than .

Gets or sets used to write the packets.

The used to write the packets. The used to write the packets.

Gets or sets the underlying .

The underlying . creates a to send logging events over a network. Classes deriving from can use this property to get or set this . Use the underlying returned from if you require access beyond that which provides.

Gets or sets the cached remote endpoint to which the logging events should be sent.

The cached remote endpoint to which the logging events will be sent. The method will initialize the remote endpoint with the values of the and properties.

This appender requires a to be set.

true This appender requires a to be set.

Syslog port 514

Initializes a new instance of the class.

This instance of the class is set up to write to a remote syslog daemon.

Add a mapping of level to severity

The mapping to add Add a mapping to this appender.

This method is called by the method.

The event to log. Writes the event to a remote syslog daemon. The format of the output will depend on the appender's layout.

Initialize the options for this appender

Initialize the level to syslog severity mappings set on this appender.

Translates a log4net level to a syslog severity.

A log4net level. A syslog severity. Translates a log4net level to a syslog severity.

Generate a syslog priority.

The syslog facility. The syslog severity. A syslog priority. Generate a syslog priority.

The facility. The default facility is .

The message identity

Mapping from level object to syslog severity

Message identity

An identifier is specified with each log message. This can be specified by setting the property. The identity (also know as the tag) must not contain white space. The default value for the identity is the application name (from ).

Syslog facility

Set to one of the values. The list of facilities is predefined and cannot be extended. The default value is .

syslog severities

The syslog severities.

system is unusable

action must be taken immediately

critical conditions

error conditions

warning conditions

normal but significant condition

informational

debug-level messages

syslog facilities

The syslog facilities

kernel messages

random user-level messages

mail system

system daemons

security/authorization messages

messages generated internally by syslogd

line printer subsystem

network news subsystem

UUCP subsystem

clock (cron/at) daemon

security/authorization messages (private)

ftp daemon

NTP subsystem

log audit

log alert

clock daemon

reserved for local use

A class to act as a mapping between the level that a logging call is made at and the syslog severity that is should be logged at.

The mapped syslog severity for the specified level

Required property. The mapped syslog severity for the specified level

Maintains a registry of type converters used to convert between types. Use the and methods to register new converters. The and methods lookup appropriate converters to use. Nicko Cadell Gert Driesen

Private constructor

Initializes a new instance of the class.

Static constructor.

This constructor defines the intrinsic type converters.

Adds a converter for a specific type.

The type being converted to. The type converter to use to convert to the destination type. Adds a converter instance for a specific type.

Adds a converter for a specific type.

The type being converted to. The type of the type converter to use to convert to the destination type. Adds a converter for a specific type.

Gets the type converter to use to convert values to the destination type.

The type being converted from. The type being converted to. The type converter instance to use for type conversions or null if no type converter is found. Gets the type converter to use to convert values to the destination type.

Gets the type converter to use to convert values to the destination type.

The type being converted to. The type converter instance to use for type conversions or null if no type converter is found. Gets the type converter to use to convert values to the destination type.

Lookups the type converter to use as specified by the attributes on the destination type.

The type being converted to. The type converter instance to use for type conversions or null if no type converter is found.

Creates the instance of the type converter.

The type of the type converter. The type converter instance to use for type conversions or null if no type converter is found. The type specified for the type converter must implement the or interfaces and must have a public default (no argument) constructor.

Mapping from to type converter.

String keyed object map.

While this collection is serializable only member objects that are serializable will be serialized along with this collection. Nicko Cadell Gert Driesen

String keyed object map that is read only.

This collection is readonly and cannot be modified. While this collection is serializable only member objects that are serializable will be serialized along with this collection. Nicko Cadell Gert Driesen

The Hashtable used to store the properties data

Constructor

Initializes a new instance of the class.

Copy Constructor

properties to copy Initializes a new instance of the class.

Deserialization constructor

The that holds the serialized object data. The that contains contextual information about the source or destination. Initializes a new instance of the class with serialized data.

Gets the key names.

An array of all the keys. Gets the key names.

Test if the dictionary contains a specified key

the key to look for true if the dictionary contains the specified key Test if the dictionary contains a specified key

Serializes this object into the provided.

The to populate with data. The destination for this serialization. Serializes this object into the provided.

See

Remove all properties from the properties collection

See

Gets or sets the value of the property with the specified key.

The value of the property with the specified key. The key of the property to get or set. The property value will only be serialized if it is serializable. If it cannot be serialized it will be silently ignored if a serialization operation is performed.

The hashtable used to store the properties

The internal collection used to store the properties The hashtable used to store the properties

See

The number of properties in this collection

See

Constructor

Initializes a new instance of the class.

Constructor

properties to copy Initializes a new instance of the class.

Initializes a new instance of the class with serialized data.

The that holds the serialized object data. The that contains contextual information about the source or destination. Because this class is sealed the serialization constructor is private.

Remove the entry with the specified key from this dictionary

the key for the entry to remove Remove the entry with the specified key from this dictionary

See

an enumerator Returns a over the contest of this collection.

See

the key to remove Remove the entry with the specified key from this dictionary

See

the key to lookup in the collection true if the collection contains the specified key Test if this collection contains a specified key.

Remove all properties from the properties collection

See

the key the value to store for the key Store a value for the specified . Thrown if the is not a string

See

Gets or sets the value of the property with the specified key.

See

false This collection is modifiable. This property always returns false.

See

The value for the key specified. Get or set a value for the specified . Thrown if the is not a string

See

Write the current process ID to the output

Write the current process ID to the output writer Nicko Cadell

Write the current process ID to the output

the writer to write to null, state is not set Write the current process ID to the output .

Configure repository using XML

Interface used by Xml configurator to configure a . A should implement this interface to support configuration by the . Nicko Cadell Gert Driesen

Initialize the repository using the specified config

the element containing the root of the config The schema for the XML configuration data is defined by the implementation.

The log4net Logical Thread Context.

The LogicalThreadContext provides a location for specific debugging information to be stored. The LogicalThreadContext properties override any or properties with the same name. The Logical Thread Context has a properties map and a stack. The properties and stack can be included in the output of log messages. The supports selecting and outputting these properties. The Logical Thread Context provides a diagnostic context for the current call context. This is an instrument for distinguishing interleaved log output from different sources. Log output is typically interleaved when a server handles multiple clients near-simultaneously. The Logical Thread Context is managed on a per basis. The requires a link time for the . If the calling code does not have this permission then this context will be disabled. It will not store any property values set on it. Example of using the thread context properties to store a username.


            LogicalThreadContext.Properties["user"] = userName;
            log.Info("This log message has a LogicalThreadContext Property called 'user'");

Example of how to push a message into the context stack


            using(LogicalThreadContext.Stacks["LDC"].Push("my context message"))
            {
            	log.Info("This log message has a LogicalThreadContext Stack message that includes 'my context message'");
            
            } // at the end of the using block the message is automatically popped

Nicko Cadell

Private Constructor.

Uses a private access modifier to prevent instantiation of this class.

The thread context properties instance

The thread context stacks instance

The thread properties map

The thread properties map The LogicalThreadContext properties override any or properties with the same name.

The thread stacks

stack map The logical thread stacks.

Adapts any to a

Where an is required this adapter allows a to be specified. Nicko Cadell Gert Driesen

The layout to adapt

Construct a new adapter

the layout to adapt Create the adapter for the specified .

Format the logging event as an object.

The event to format returns the formatted event Format the logging event as an object. Uses the object supplied to the constructor to perform the formatting.

This is a very simple filter based on matching.

The filter admits two options and . If there is an exact match between the value of the option and the of the , then the method returns in case the option value is set to true, if it is false then is returned. If the does not match then the result will be . Nicko Cadell Gert Driesen

flag to indicate if the filter should on a match

the to match against

Default constructor

Tests if the of the logging event matches that of the filter

the event to filter see remarks If the of the event matches the level of the filter then the result of the function depends on the value of . If it is true then the function will return , it it is false then it will return . If the does not match then the result will be .

when matching

The property is a flag that determines the behavior when a matching is found. If the flag is set to true then the filter will the logging event, otherwise it will the event. The default is true i.e. to the event.

The that the filter will match

The level that this filter will attempt to match against the level. If a match is found then the result depends on the value of .

The implementation of the interface suitable for use with the compact framework

This implementation is a simple mapping between repository name and object. The .NET Compact Framework 1.0 does not support retrieving assembly level attributes therefore unlike the DefaultRepositorySelector this selector does not examine the calling assembly for attributes. Nicko Cadell

Interface used by the to select the .

The uses a to specify the policy for selecting the correct to return to the caller. Nicko Cadell Gert Driesen

Gets the for the specified assembly.

The assembly to use to lookup to the The for the assembly. Gets the for the specified assembly. How the association between and is made is not defined. The implementation may choose any method for this association. The results of this method must be repeatable, i.e. when called again with the same arguments the result must be the save value.

Gets the named .

The name to use to lookup to the . The named Lookup a named . This is the repository created by calling .

Creates a new repository for the assembly specified.

The assembly to use to create the domain to associate with the . The type of repository to create, must implement . The repository created. The created will be associated with the domain specified such that a call to with the same assembly specified will return the same repository instance. How the association between and is made is not defined. The implementation may choose any method for this association.

Creates a new repository with the name specified.

The name to associate with the . The type of repository to create, must implement . The repository created. The created will be associated with the name specified such that a call to with the same name will return the same repository instance.

Test if a named repository exists

the named repository to check true if the repository exists Test if a named repository exists. Use to create a new repository and to retrieve a repository.

Gets an array of all currently defined repositories.

An array of the instances created by this . Gets an array of all of the repositories created by this selector.

Event to notify that a logger repository has been created.