Package: log2d
log2d- Simple, sane, and sensible loggingINTRODUCTIONlog2dis an incredibly helpful wrapper around Python'sloggingmodule in the standard library and can be installed via PIP in the normal way:python -m pip install log2d --upgradeIt aims to provide the best parts oflogging(like automatic, rotating backup files) to users who don't want or need to learn every nuance of the module itself and perhaps simply want to wean themselves offprint()statements and organise their output in a better "2 Dimensional" way (hence the name -log2d).If you've dipped into the standardloggingdocumentation you'd be forgiven for thinking you can only log output according to the prescribed log levels: DEBUG, INFO, WARNING, ERROR, or CRITICAL/FATAL.  Such an approach is linear or "1 Dimensional" since it's based solely on theimportanceof a message.A very common use case however is the need to capture differenttypesof message.  Hence TWO dimensions.In web-scraping apps for example, it's useful to collect the HTTP requests which succeeded or failed or needed a few retries, quite apart from any general Exceptions arising from your actual code.  You might also want a nice (separate) log of overall progress and timings i.e. how long particular scrapers take to complete.log2dmakes it simple to create, customise, and use a new logger for each of these types of output, for example sendingprogressmessages just to the console, and creating separate.logfiles forsuccesses,failures,retries,exceptions, andtimings.It does so in a concise, readable, and (dare I claim?) "Pythonic" way, that doesn't require mastery of theloggingmodule itself.  It allows you to create a sophisticated logger with powerful default features enabled in just one line of code, then send output to that logger whenever and from wherever you like - also in just one line.At the end of this README there are some simple Cookbook recipes for dynamically creating a log for any given Module, Class, or Instance.SETUPSimply import theLogclass into your Python script:from log2d import LogBASIC USECreate a named logger that only outputs to the console ("stdout") using default message formatting and date format:Log("main")
Log.main.warning("Danger, Will Robinson!")

Output:
main|WARNING |2022-10-25T19:34:30+0100|Danger, Will Robinson!In place of.warningyou can use any of the standard log levels, either upper or lower case: DEBUG, INFO, WARNING, ERROR, and CRITICAL/FATALCreate a logger that just outputs to a file:log_success = Log("success", to_file=True)
log_success("log2d for the win!")
Log.success.critical("Alert! Alert!")

(Creates and updates ./success.log)NB The 'sensible' default logic oflog2dassumes that if you ONLY specifyto_fileas a parameter, you ONLY want output to go to file, and output to the console (to_stdout) is automatically set toFalseThe default values forto_stdoutandto_fileareTrueandFalserespectively.  In other words if you provide neither parameter, logging is to the console only.The default file loggingmodeisa- append log messages to the existing log mode indefiintely.  See below for file logging modewwhich overwrites the log file each time the script is run.Specify a folder/directory for a specific logger:Log("my_title", path="./output")NBto_fileis automatically set to True if apathis supplied.The default path is the current working directory""or"."If a non-existent folder/directory is specified,FileNotFoundErrorwill be raised.Set a minimum level of message to capture (in plain English rather than using numeric values):Log("my_title", level="WARNING")Create your own shortcut to log a message at the default level:For simple scripts with no or few imports you might like to create your own shortcut functions like this:log_failure = Log("failures")
log_failure("Insert your failure message here")

Output:
failures|DEBUG   |2022-10-25T19:35:06+0100|Insert your failure message hereNormal considerations regardingnamespacesapply however, and for longer/more complex scripts it might be wiser to stick with the explicit naming conventionLog.logger_name().You could use this shortcut feature to overwrite theprintfunctions in existing code, and convert every oldprint()line into a logging command._print = print; print = Log("print")The default log level used bylog2dis actually DEBUG, whereas theloggingdefault is WARNING.  This change is intended to make things safer and more predictable for new users who might otherwise be sending DEBUG and INFO level messages and wondering why they're not being logged.ABOUT LOGGER NAMESYoucancreate a logger name with spaces and other characters rather than underscores, but you wouldn't then be able to use Python's nice.attributenotation.  If your log name was "my main log" you'd need to usegetattr(Log, "my main log").warning("...")instead, which is a bit messy.  Best to just use underscores if you can.Just as in the standardloggingmodule, the name "root" is reserved for a special type of logger which actually inherits from other loggers.  This can be very helpful if you want a single "master" logger that records absolutely everything, but also a bit annoying if you weren't aware of it and have already explicitly disabled output at a particular level, only to see it appear in your "root" logger.  Here's a quick example to demonstrate how this works:Log("main")
Log.main.info("This is the MAIN logger")

Output:
main|INFO   |2022-10-08T23:47:08+0100|This is the MAIN logger

Log("root", fmt=Log.presets['timestamp_only'])
Log.root.info("This message is for ROOT only")

Output:
2022-10-08T23:52:09+0100|This message is for ROOT only

Log.main.info("This message will be echoed by BOTH loggers")

Output:
main|INFO   |2022-10-08T23:49:23+0100|This message will be echoed by BOTH loggers
2022-10-08T23:49:23+0100|This message will be echoed by BOTH loggersIf you don't want to use this 'inheritance' feature, just avoid using the name "root" for any of yourlog2dloggers.(See also USING LOGGING AND LOG2D AT THE SAME TIME below)OTHER KEYWORD OPTIONS AND UTILITY METHODSAdd Custom logging levelsfrom log2d import Log, logging

mylog = Log("mylog")

mylog.add_level("NewError", below="ERROR")
mylog.add_level("NewInfo", above="INFO")

Log.mylog.newerror(f"New log level {logging.NEWERROR} below ERROR")
Log.mylog.newinfo(f"New log level {logging.NEWINFO} above INFO ")

Output:
"New log level 'newerror' added with value: 39"
"New log level 'newinfo' added with value: 21"
mylog|NEWERROR|2022-11-09T06:17:00+0000|New log level 39 below ERROR
mylog|NEWINFO |2022-11-09T06:17:17+0000|New log level 21 above INFOThis method returns a confirmation message rather than logging its own output and potentially messing up your pristine logging schema.  You can suppress it by assigning a dummy variable e.g._ = mylog.add_level("NewError", below="ERROR").add_level()will also overwrite previous log levels at a given value if they already exist, and create the new log levelimmediatelyabove or below the reference log level i.e. without leaving any gaps.  For explicit control over the postion of log levels, you can also specify the log level value numerically:mylog.add_level("TRACE", 15)
Log.mylog.trace("Trace message...")Create a new log file for each session overwriting the previous file each time:results = Log("session_results", to_file=True, mode="w")Create a new log file for each session and automatically create 10 rotating backups:results = Log("session_results", to_file=True, mode="w", backup_count=10)The current log file will always besession_results.logbut for subsequent sessions this will be copied tosession_results.log.1thensession_results.log.2etc until the backup count is reached, then start again on a rotating basis.Ifbackup_countis not specified, the default number of backups is 5.Preview a particular message format and/or date format - either one of the supplied presets, or one of your own design:Log.preview(fmt=Log.presets["timestamp_only"], datefmt=Log.date_formats["time"])

Output:
13:10:06|This is a preview log entry.

Log.preview(datefmt="%m-%d::%H:%M")

Output:
temp_preview|09-25::15:36|This is a preview log entry.Preview all combinations of message/date presets:Log.preview_all()List allLoginstances:Log.indexAccess the underlyinglogging.Loggerobject for even more controllogger = Log("main").logger

type(logger)
<class 'logging.Logger'>

dir(logger)
[...
'addFilter', 'addHandler', 'callHandlers', 'critical', 'debug', 'disabled', 'error', 'exception', 'fatal', 'filter', 'filters', 'findCaller', 'getChild', 'getEffectiveLevel', 'handle', 'handlers', 'hasHandlers', 'info', 'isEnabledFor', 'level', 'log', 'makeRecord', 'manager', 'name', 'parent', 'propagate', 'removeFilter', 'removeHandler', 'root', 'setLevel', 'warn', 'warning']COOKBOOKRecipe 1: Create one log file per Modulefrom log2d import Log, Path

if __name__ == '__main__':
    log = Log(Path(__file__).stem, to_file=True).logger

    # Then just reuse the log object elsewhere in your script e.g.:
    file_name = Path(__file__).name
    log.critical(f'critical message from: {file_name}')
    log.error(f'error message from: {file_name}')
    log.warning(f'new warning message from: {file_name}')
    log.info(f'info message from: {file_name}')
    log.debug(f'debug message from: {file_name}')

"""
OUTPUT:
my_file|CRITICAL|2022-10-25T16:32:50+0100|critical message from: my_file.py
my_file|ERROR   |2022-10-25T16:32:50+0100|error message from: my_file.py
my_file|WARNING |2022-10-25T16:32:50+0100|new warning message from: my_file.py
my_file|INFO    |2022-10-25T16:32:50+0100|info message from: my_file.py
my_file|DEBUG   |2022-10-25T16:32:50+0100|debug message from: my_file.py
"""Recipe 2: Create one log file per Instancefrom log2d import Log

class MyClass:
    def __init__(self, name):
        params = {"fmt": Log.presets["name_and_time"]}
        self.log = Log.index.get(name) or Log(name, **params)

    def method_1(self):
        # Do something
        self.log("method_1 did something!")

x = MyClass("Instance 1")
x.method_1()
y = MyClass("Instance 2")
y.method_1()
x.log("This message was logged directly")
y.log("Likewise, but different instance")

"""
OUTPUT:
Instance 1|2022-10-16T08:50:29+0100|method_1 did something!
Instance 2|2022-10-16T08:29:05+0100|method_1 did something!
Instance 1|2022-10-16T08:53:17+0100|This message was logged directly
Instance 2|2022-10-16T08:54:06+0100|Likewise, but different instance
"""Recipe 3: Create one log file per Modulefrom log2d import Log

class MyAbstractClass:
    def __init__(self, name, *args, **kwargs):
        params = {"fmt": Log.presets["name_and_time"]}
        self.log = Log.index.get(name) or Log(name, **params)

class MyClass(MyAbstractClass):
    def __init__(self, name, *args, **kwargs):
        super().__init__(self.__class__.__name__, *args, **kwargs)
        self.name = name

    def method_1(self):
        # Do something
        self.log(f"method_1 of {self.name} did something!")

x = MyClass("Instance X")
x.method_1()
y = MyClass("Instance Y")
y.method_1()
x.log(f"This message was logged by {x.name}")
y.log(f"And this one by {y.name}")

"""
OUTPUT:
MyClass|2022-10-16T08:43:31+0100|method_1 of Instance X did something!
MyClass|2022-10-16T08:43:45+0100|method_1 of Instance Y did something!
MyClass|2022-10-16T08:57:52+0100|This message was logged by Instance X
MyClass|2022-10-16T08:58:18+0100|And this one by Instance Y
"""Recipe 4: Use a preset message/date format, or supply your own:fmt = Log.presets["file_func_name"]
datefmt = Log.date_formats["date_and_time"]

Log("main", fmt=fmt, datefmt=datefmt)fmt = '%(asctime)s:%(levelname)s:%(name)s:%(message)s'
datefmt = '%d/%m/%Y %I:%M:%S %p'

Log("main", fmt=fmt, datefmt=datefmt)For more information on composing your own formats see:https://docs.python.org/3/library/logging.html#formatter-objectshttps://docs.python.org/3/library/logging.html#logging.LogRecordRecipe 5: Add a new date format or message format preset at the Class level, so that future instances can use them:fmt = "%(asctime)s (%(name)s): %(message)s"
datefmt = "%m-%d %H:%M"

Log.presets["my_message_format"] = fmt
Log.date_formats["my_date_format"] = datefmtRecipe 6: Example web-scraping setupAs shown earlier, values forlevel,fmt,datefmt,to_file,to_stdout,path,mode, andbackup_countcan be set for a specific logger by supplying them as keyword arguments on initialisation.Where no argument is supplied for a new logger, the Class level defaults will be used.  Default attributes can also be set at a class level so that all subsequent loggers have the same or similar settings:from log2d import Log

ROOT_DIR = "./my_app_path"

Log.path = f"{ROOT_DIR}/logs/"
Log.fmt = Log.presets["name_and_time"]
Log.datefmt = Log.date_formats["time"]
Log.to_file = True
Log.to_stdout = False
Log.mode = "w"
Log.backup_count = 10

Log("main", to_stdout=True)
Log("selenium")
Log("requests")
Log("timings")
Log("results")
Log("retries")
Log("errors")USING LOGGING AND LOG2D AT THE SAME TIMEYou may find yourself using code that already hasloggingenabled.  This won't interfere with any loggers yousubsequentlycreate withlog2dbut you might find that somelog2dmessages are repeated (inhrerited) by the existing RootLoggerlogging.Logger.root, for example echoing WARNING level messages to stdout even though you've explicitly disabled this in yourlog2dlogger.In case you were wondering, alog2dlogger called "root" will inherit from otherlog2dloggers in a similar way to RootLogger but it is not the same entity aslogging.Logger.rootcreated by downstream code you've imported from.  Both can exist at the same time and be configured to behave differently.So... if you're able to amend the original code where logging is enabled, the best way to ensure consistent behaviour is to replaceloggingwithlog2dentirely:Replaceimport loggingwithfrom log2d import LogCreate a new "root" logger withlog2dand specify how you want it to work in the normal way e.g.Log("root", level="INFO")Replacelogger.info(),logger.warning()etc withLog.root.info(),Log.root.warning()etc.Another option is to disable the RootLogger using thelog2dconvenience function:Log.disable_rootlogger()This is a bit of a blunt instrument and basically finds all the Handlers used by RootLogger (logging.Logger.root.handlers) and runs the.removeHandler()method on them.If neither of these approaches give you what you need, you can dive a bit deeper into theLog.get_handlersmethod oflog2dor see above for accessubg the underlyinglogging.Loggerobject.If you find yourself doing this, you'll inevitably find yourself reading the standard libraryloggingdocumentation which of course goes against the very reason forlog2d's existence - to offer simple, sane, and sensible loggingwithoutthe pain of having to learn its innner workings.  So if you've reached this point and need more control or sophistication with your logging, thenlog2dhas probably served it's purpose and you're ready to move onwards and upwards!FEEDBACK AND CONTRIBUTINGI'd be delighted to hear any suggestions, bug reports, or comments in the form of a Github ISSUE, and if you've foundlog2duseful or merely interesting please do click the "Star" button.  It really raises my spirits to see that kind of feedback.If you're in paid employment andlog2dhas saved you even a few minutes' effort, please consider how much this gift is worth based on your daily/hourly earnings, and whether it might feel good to at least leave a nice comment on BuyMeaCoffee.com?  Thank you.