{"id":30735707,"url":"https://github.com/jpdillingham/nlog.xlogger","last_synced_at":"2025-09-03T20:13:39.371Z","repository":{"id":9063943,"uuid":"60378127","full_name":"jpdillingham/NLog.xLogger","owner":"jpdillingham","description":"A C# .NET class library that extends NLog.Logger to provide additional functionality for tracing the entry and exit, arbitrary checkpoints, exceptions and stack traces within methods.","archived":false,"fork":false,"pushed_at":"2022-06-22T16:07:08.000Z","size":144,"stargazers_count":33,"open_issues_count":3,"forks_count":2,"subscribers_count":5,"default_branch":"master","last_synced_at":"2025-08-05T23:31:42.407Z","etag":null,"topics":["csharp","logging","nlog","xlogger"],"latest_commit_sha":null,"homepage":"http://dillingham.ws/tools/xLogger-An-NLog-Extension-Class/","language":"C#","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/jpdillingham.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2016-06-03T21:15:13.000Z","updated_at":"2023-09-08T17:11:08.000Z","dependencies_parsed_at":"2022-09-15T06:51:11.338Z","dependency_job_id":null,"html_url":"https://github.com/jpdillingham/NLog.xLogger","commit_stats":null,"previous_names":["jpdillingham/xlogger"],"tags_count":5,"template":false,"template_full_name":null,"purl":"pkg:github/jpdillingham/NLog.xLogger","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jpdillingham%2FNLog.xLogger","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jpdillingham%2FNLog.xLogger/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jpdillingham%2FNLog.xLogger/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jpdillingham%2FNLog.xLogger/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/jpdillingham","download_url":"https://codeload.github.com/jpdillingham/NLog.xLogger/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/jpdillingham%2FNLog.xLogger/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":273502354,"owners_count":25117173,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-09-03T02:00:09.631Z","response_time":76,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["csharp","logging","nlog","xlogger"],"created_at":"2025-09-03T20:13:24.611Z","updated_at":"2025-09-03T20:13:39.357Z","avatar_url":"https://github.com/jpdillingham.png","language":"C#","funding_links":[],"categories":[],"sub_categories":[],"readme":"# NLog.xLogger\n\n[![Build status](https://ci.appveyor.com/api/projects/status/gb3d82pasjqgihjr?svg=true)](https://ci.appveyor.com/project/jpdillingham/nlog-xlogger)\n[![Build Status](https://travis-ci.org/jpdillingham/NLog.xLogger.svg?branch=master)](https://travis-ci.org/jpdillingham/NLog.xLogger)\n[![codecov](https://codecov.io/gh/jpdillingham/NLog.xLogger/branch/master/graph/badge.svg)](https://codecov.io/gh/jpdillingham/NLog.xLogger)\n[![NuGet version](https://img.shields.io/nuget/v/NLog.xLogger.svg)](https://www.nuget.org/packages/NLog.xLogger/)\n[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/jpdillingham/NLog.xLogger/blob/master/LICENSE)\n\nAn extension of NLog.Logger that provides additional functionality for tracing the entry and exit, arbitrary checkpoints, exceptions and stack traces within methods.\n\nThis library depends on [NLog](https://www.nuget.org/packages/NLog/), [Json.NET](https://www.nuget.org/packages/Newtonsoft.Json) and my own [BigFont Class](https://github.com/jpdillingham/BigFont).\n\n## Installation\n\nInstall from the NuGet gallery GUI or with the Package Manager Console using the following command:\n\n```Install-Package NLog.xLogger```\n\n## NLog.xLogger\n\nThe ```xLogger``` class is the only type within the namespace.  This type extends ```NLog.Logger```.\n\n### Instantiating\n\nxLogger instances are instantiated using the ```LogManager.GetLogger()``` and ```LogManager.GetCurrentClassLogger()``` factory methods provided by NLog.  \n\nThe ```GetCurrentClassLogger()``` method returns an instance of xLogger named using the current class name.\n\n```c#\nprivate xLogger logger = (xLogger)LogManager.GetCurrentClassLogger(typeof(xLogger));\n```\n\nNote that ```typeof(xLogger)``` must be passed to the factory method so that the correct type can be instantiated.  The result of the method must also be cast to xLogger.\n\nThe ```GetLogger()``` method returns a named instance of xLogger using the supplied name.\n\n```c#\nprivate xLogger logger = (xLogger)LogManager.GetLogger(\"generic logger name\", typeof(xLogger));\n```\n\n#### xLogManager\n\nThe ```xLogManager``` wrapper for ```LogManager``` may also be used to create instances of xLogger using the ```GetCurrentClassxLogger()``` and ```GetxLogger()``` methods.\n\n```c#\nprivate xLogger logger = xLogManager.GetxLogger(\"generic name\");\nprivate xLogger logger = xLogManager.GetCurrentClassxLogger();\n```\n\n### Methods\n#### EnterMethod()\n\nThe ```EnterMethod()``` method is used to log the entry point of a method.  The method accepts an object array containing the method parameters and boolean used to determine whether to persist the timestamp of entry.  Returns a ```Guid``` if persistence is used, ```default(Guid)``` otherwise.\n\nThe static method ```xLogger.Params()``` is included to assist with the building of the object array.  Pass each method parameter, in order, to this method and an object array containing the passed arguments is returned.  If you wish to exclude any arguments from logging, replace the passed argument with ```new xLogger.ExcludedParam()```.  This maintains proper positioning, which is important so that reflection can retrieve the name and type of the parameter.\n\nNote that the class ExampleObject has been created to demonstrate the serialization functionality and will continue to be used for the remainder of the examples.\n\n##### Example\n\n```c#\npublic static void EnterMethodExample(int one, int two, ExampleObject three)\n{\n    logger.EnterMethod(xLogger.Params(one, two, three));\n\n    // method body\n    logger.Trace(\"Standard log message\");\n}\n```\n\n##### Output\n\n```\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ ──► Entering method: Void EnterMethodExample\u003cTone, Ttwo\u003e(Int32 one, Int32 two, ExampleObject three) (Program.cs:line 56)\n[x]: │   ├┄┈ Tone: System.String\n[x]: │   ├┄┈ Ttwo: System.Boolean\n[x]: │   ├┄┈ one: 1\n[x]: │   ├┄┈ two: 2\n[x]: │   ├┄┈ three: {\n[x]: │   ├┄┈ three:   \"Num\": 3,\n[x]: │   ├┄┈ three:   \"Str\": \"three\",\n[x]: │   ├┄┈ three:   \"List\": [\n[x]: │   ├┄┈ three:     1.1,\n[x]: │   ├┄┈ three:     2.2,\n[x]: │   ├┄┈ three:     3.3\n[x]: │   ├┄┈ three:   ]\n[x]: │   └┄┈ three: }\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: Standard log message \n```\n\n#### ExitMethod()\n\nThe ```ExitMethod()``` method logs the exit point of a method.  The method accepts an object representing the method return value and an optional ```Guid```, used if the corresponding ```EnterMethod()``` was called with the persistence option.\n\n##### Example\n\n```c#\npublic static ExampleObject ExitMethodPersistentExample(int one, int two)\n{\n    Guid persistedGuid = logger.EnterMethod(xLogger.Params(one, two), true);\n\n    // method body\n\n    logger.Trace(\"Standard log message\");\n    ExampleObject returnValue = new ExampleObject(1, \"return\", new double[] { 5.5 }.ToList());\n\n    logger.ExitMethod(returnValue, persistedGuid);\n    return returnValue;\n}\n```\n\n##### Output\n\n```\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ ──► Entering method: ExampleObject ExitMethodPersistentExample(Int32 one, Int32 two) (Program.cs:line 71), persisting with Guid: ee9f56c7-f910-447b-8d03-e14bd8598654\n[x]: │   ├┄┈ one: 1\n[x]: │   └┄┈ two: 2\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: Standard log message\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ ◄── Exiting method: ExampleObject ExitMethodPersistentExample(Int32 one, Int32 two) (Program.cs:line 78), Guid: ee9f56c7-f910-447b-8d03-e14bd8598654\n[x]: │   ├┄┈ return: {\n[x]: │   ├┄┈ return:   \"Num\": 1,\n[x]: │   ├┄┈ return:   \"Str\": \"return\",\n[x]: │   ├┄┈ return:   \"List\": [\n[x]: │   ├┄┈ return:     5.5\n[x]: │   ├┄┈ return:   ]\n[x]: │   └┄┈ return: }\n[x]: ├────────────────────────────────────┄┈\n[x]: │ ◊ Method execution duration: 2.0017ms\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n\n```\n\n#### Checkpoint()\n\nThe ```Checkpoint()``` method logs an arbitrary checkpoint anywhere within the method body.  The method accepts a string representing the name of the checkpoint, an object array containing an arbitrary list of variables, a string array containing the names of the variables contained in the object list, and an optional ```Guid```, used if the corresponding ```EnterMethod()``` call used the persistence option.\n\n##### Example\n\n```c#\npublic static int CheckpointExample(int one)\n{\n    Guid persistedGuid = logger.EnterMethod(xLogger.Params(one), true);\n\n    logger.Trace(\"Standard log message\");\n    int two = 2;\n    int three = 3;\n\n    logger.Checkpoint(\"example checkpoint\", xLogger.Vars(one, two, three), xLogger.Names(\"one\", \"two\", \"three\"), persistedGuid);\n\n    logger.Trace(\"Another standard log message\");\n\n    int returnValue = one + two + three;\n\n    logger.ExitMethod(returnValue, persistedGuid);\n    return returnValue;\n}\n```\n\n##### Output\n\n```\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ ──► Entering method: Int32 CheckpointExample(Int32 one) (Program.cs:line 89), persisting with Guid: 9792bbef-4609-429d-a0d3-478ba65e9b0e\n[x]: │   └┄┈ one: 1\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: Standard log message\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ √ Checkpoint 'example checkpoint' reached in method: Int32 CheckpointExample(Int32 one) (Program.cs:line 95), Guid: 9792bbef-4609-429d-a0d3-478ba65e9b0e\n[x]: │   ├┄┈ one: 1\n[x]: │   ├┄┈ two: 2\n[x]: │   └┄┈ three: 3\n[x]: ├────────────────────────────────────┄┈\n[x]: │ ◊ Current execution duration: 1.0009ms\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: Another standard log message\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ ◄── Exiting method: Int32 CheckpointExample(Int32 one) (Program.cs:line 101), Guid: 9792bbef-4609-429d-a0d3-478ba65e9b0e\n[x]: │   └┄┈ return: 6\n[x]: ├────────────────────────────────────┄┈\n[x]: │ ◊ Method execution duration: 1.0009ms\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n```\n\n#### Exception()\n\nThe ```Exception()``` method logs exception details.  The method differs from the others in that it can log to levels other than Trace.  The first parameter is of type ```LogLevel``` which is an enumeration of the logging levels within NLog.  \nOther parameters are the ```Exception``` that was caught and, as always, the optional ```Guid``` created if the method was entered with the persistence option.\n\n##### Example\n\n```c#\npublic static void ExceptionExample()\n{\n\tlogger.EnterMethod();\n\n\ttry\n\t{\n\t\t// intentionally raise an exception\n\t\tvar arr = new string[5];\n\t\tConsole.WriteLine(arr[5]);\n\t}\n\tcatch (Exception ex)\n\t{\n\t\tlogger.Exception(LogLevel.Error, ex);\n\t}\n\tfinally\n\t{\n\t\tlogger.ExitMethod();\n\t}\n}\n```\n\n##### Output\n\n```\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ ──► Entering method: Void ExceptionExample() (Program.cs:line 110)\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: ┌──┐┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │██││ ╳ Exception 'IndexOutOfRangeException' caught in method: Void ExceptionExample() (Program.cs:line 120)\n[x]: │██││   └┄┈ \"Index was outside the bounds of the array.\"\n[x]: │██│├────────────────────────────────────┄┈\n[x]: │██││   └┄► Void Main(String[] args)\n[x]: │██││      └┄► Void ExceptionExample()\n[x]: │██│├────────────────────────────────────┄┈\n[x]: │██││   ├┄┈ ex: {\n[x]: │██││   ├┄┈ ex:   \"ClassName\": \"System.IndexOutOfRangeException\",\n[x]: │██││   ├┄┈ ex:   \"Message\": \"Index was outside the bounds of the array.\",\n[x]: │██││   ├┄┈ ex:   \"Data\": null,\n[x]: │██││   ├┄┈ ex:   \"InnerException\": null,\n[x]: │██││   ├┄┈ ex:   \"HelpURL\": null,\n[x]: │██││   ├┄┈ ex:   \"StackTraceString\": \"\n[x]: │██││   ├┄┈ ex:       at NLog.xLogger.Examples.Program.ExceptionExample() in C:\\Users\\JP.WHATNET\\Google Drive\\Projects\\xLogger\\Examples\\Program.cs:line 116\n[x]: │██││   ├┄┈ ex:   \"\n[x]: │██││   ├┄┈ ex:   \"RemoteStackTraceString\": null,\n[x]: │██││   ├┄┈ ex:   \"RemoteStackIndex\": 0,\n[x]: │██││   ├┄┈ ex:   \"ExceptionMethod\": \"8\\nExceptionExample\\nExamples, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null\\nNLog.xLogger.Examples.Program\\nVoid ExceptionExample()\",\n[x]: │██││   ├┄┈ ex:   \"HResult\": -2146233080,\n[x]: │██││   ├┄┈ ex:   \"Source\": \"Examples\",\n[x]: │██││   ├┄┈ ex:   \"WatsonBuckets\": null\n[x]: │██││   └┄┈ ex: }\n[x]: └──┘└──────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ ◄── Exiting method: Void ExceptionExample() (Program.cs:line 124)\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n```\n\n#### Stack Trace\nThe ```StackTrace``` method logs the current call stack at the point of invocation.\n\n##### Example\n\n```c#\npublic static void StackTraceExample()\n{\n    logger.StackTrace(LogLevel.Info);\n}\n```\n\n##### Output\n\n```\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ @ Stack Trace from method: Void StackTraceExample() (Program.cs:line 133)\n[x]: │   └┄► Void Main(String[] args)\n[x]: │      └┄► Void StackTraceExample()\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n```\n\n#### Additional Methods\n\n* ```Multiline(LogLevel, string|string[])```: Logs the provided string or string array in multiple lines, split around the array elements or newline characters.\n* ```MultilineWrapped(LogLevel, string|string[])```: Same as above, but wrapped in the stylized lines seen in the examples above.\n* ```Separator(LogLevel)```: Logs a horizontal line\n* ```Heading(LogLevel, string)```: Logs the provided string in large letters (provided by BigFont), followed by a separator.\n* ```SubHeading(LogLevel, string)```: Logs the provided string in medium letters.\n* ```SubSubHeading(LogLevel, string)```: Logs the provided string in smaller letters.\n\n##### Example\n\n```c#\npublic static void OtherExamples()\n{\n    logger.Multiline(LogLevel.Trace, \"hello \\n world!\");\n    logger.MultilineWrapped(LogLevel.Trace, new string[] { \"hello\", \"again\", \"world!!\" });\n    logger.Separator(LogLevel.Trace);\n    logger.Heading(LogLevel.Trace, \"Hello world!\");\n    logger.SubHeading(LogLevel.Trace, \"Hello world!\");\n    logger.SubSubHeading(LogLevel.Trace, \"Hello world!\");\n}\n```\n\n##### Output\n\n```\n[x]: hello\n[x]:  world!\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ hello\n[x]: │ again\n[x]: │ world!!\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ ███    ███ ████████ ███       ███        ▄██████▄         ███         ███  ▄██████▄  ████████▄   ███       ████████▄  ▄███▄\n[x]: │ ███    ███ ███      ███       ███       ███    ███        ███         ███ ███    ███ ███    ███  ███       ███   ▀███ █████\n[x]: │ ███    ███ ███      ███       ███       ███    ███        ███         ███ ███    ███ ███    ███  ███       ███    ███ █████\n[x]: │ ███▄▄▄▄███ ███▄▄▄   ███       ███       ███    ███        ███         ███ ███    ███ ███    ███  ███       ███    ███ █████\n[x]: │ ███▀▀▀▀███ ███▀▀▀   ███       ███       ███    ███        ███   ▄█▄   ███ ███    ███ ████████▀   ███       ███    ███ ▀███▀\n[x]: │ ███    ███ ███      ███       ███       ███    ███        ███  ▄█▀█▄  ███ ███    ███ ███▀██▄     ███       ███    ███  ███\n[x]: │ ███    ███ ███      ███       ███       ███    ███        ███ ▄█▀ ▀█▄ ███ ███    ███ ███  ▀██▄   ███       ███   ▄███\n[x]: │ ███    ███ ████████ █████████ █████████  ▀██████▀         █████▀   ▀█████  ▀██████▀  ███    ▀██▄ █████████ ████████▀   ███\n[x]: │ ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ ██   ██ ██████ ██       ██       ▄██████▄      ██      ██ ▄██████▄ ██████▄ ██       ██████▄  ▄███▄\n[x]: │ ██   ██ ██     ██       ██       ██    ██      ██      ██ ██    ██ ██   ██ ██       ██   ▀██ █████\n[x]: │ ██▄▄▄██ ██▄▄   ██       ██       ██    ██      ██      ██ ██    ██ ██   ██ ██       ██    ██ ▀███▀\n[x]: │ ██▀▀▀██ ██▀▀   ██       ██       ██    ██      ██ ▄██▄ ██ ██    ██ ██████▀ ██       ██    ██  ███\n[x]: │ ██   ██ ██     ██       ██       ██    ██      ██▄█▀▀█▄██ ██    ██ ██▀██▄  ██       ██   ▄██\n[x]: │ ██   ██ ██████ ████████ ████████ ▀██████▀      ███▀  ▀███ ▀██████▀ ██  ▀██ ████████ ██████▀   ███\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: ┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈\n[x]: │ ██  ██ █████ ██     ██     ▄████▄    ██   ██ ▄████▄ ████▄ ██     █████▄ ▄██▄\n[x]: │ ██▄▄██ ██▄▄  ██     ██     ██  ██    ██   ██ ██  ██ ██ ██ ██     ██  ██ ▀██▀\n[x]: │ ██▀▀██ ██▀▀  ██     ██     ██  ██    ██ ▄ ██ ██  ██ ████▀ ██     ██  ██  ██\n[x]: │ ██  ██ █████ ██████ ██████ ▀████▀    ███▀███ ▀████▀ ██▀█▄ ██████ █████▀  ▄▄\n[x]: └──────────────────────────────────────────────────────────────────────────────────────────┄┈\n```\n\n# Notes\n\n## Performance\n\nPerformance is severely impacted with the Trace logging level enabled.  To alleviate this, configure NLog to asynchronously by adding the following to the configuration:\n\n```\u003ctargets async=\"true\"\u003e```\n\n## Customization\n\nThe formatting of the output can be customized by creating and modifying the following variables within the NLog configuration.\n\n```xml\n  \u003cvariable name=\"xLogger.Prefix\" value=\"│ \"/\u003e\n  \u003cvariable name=\"xLogger.Header\" value=\"┌────────────────────────────────────────────────────────────────────────────────────────────────────┄┈ \"/\u003e\n  \u003cvariable name=\"xLogger.EnterPrefix\" value=\"${xLogger.Prefix}──► \"/\u003e\n  \u003cvariable name=\"xLogger.ExitPrefix\" value=\"${xLogger.Prefix}◄── \"/\u003e\n  \u003cvariable name=\"xLogger.CheckpointPrefix\" value=\"${xLogger.Prefix}√ \"/\u003e\n  \u003cvariable name=\"xLogger.ExceptionPrefix\" value=\"${xLogger.Prefix}╳ \"/\u003e\n  \u003cvariable name=\"xLogger.StackTracePrefix\" value=\"${xLogger.Prefix}@ \"/\u003e\n  \u003cvariable name=\"xLogger.ExecutionDurationPrefix\" value=\"${xLogger.Prefix}◊ \"/\u003e\n  \u003cvariable name=\"xLogger.LinePrefix\" value=\"${xLogger.Prefix}  ├┄┈ \"/\u003e\n  \u003cvariable name=\"xLogger.FinalLinePrefix\" value=\"${xLogger.Prefix}  └┄┈ \"/\u003e\n  \u003cvariable name=\"xLogger.LinePrefixVariable\" value=\"${xLogger.Prefix}  $└┄► \"/\u003e\n  \u003cvariable name=\"xLogger.Footer\" value=\"└──────────────────────────────────────────────────────────────────────────────────────────┄┈ \"/\u003e\n  \u003cvariable name=\"xLogger.InnerSeparator\" value=\"├────────────────────────────────────┄┈ \"/\u003e\n  \u003cvariable name=\"xLogger.OuterSeparator\" value=\"■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■\"/\u003e\n  \u003cvariable name=\"xLogger.ExceptionHeaderPrefix\" value=\"┌──┐\"/\u003e\n  \u003cvariable name=\"xLogger.ExceptionLinePrefix\" value=\"│██│\"/\u003e\n  \u003cvariable name=\"xLogger.ExceptionFooterPrefix\" value=\"└──┘\"/\u003e\n  \u003cvariable name=\"xLogger.HeadingFont\" value=\"Block\"/\u003e\n  \u003cvariable name=\"xLogger.SubHeadingFont\" value=\"Block\"/\u003e\n  \u003cvariable name=\"xLogger.SubSubHeadingFont\" value=\"Block\"/\u003e\n  \u003cvariable name=\"xLogger.Indent\" value=\"3\"/\u003e\n  \u003cvariable name=\"xLogger.AutoPruneEnabled\" value=\"true\"/\u003e\n  \u003cvariable name=\"xLogger.AutoPruneAge\" value=\"300\"/\u003e\n```\n\nIf any of the variables above are missing from the configuration, the default values are used.  The default values are hard coded within the library but are shown above for demonstration.","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjpdillingham%2Fnlog.xlogger","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fjpdillingham%2Fnlog.xlogger","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fjpdillingham%2Fnlog.xlogger/lists"}