goatl 0.6.5

The goat logger

---

goatl

Installation

pip install -U goatl

or install with Poetry

poetry add goatl

Purpose

goatl provides a simple and easy to use logging interface for python projects. by replacing repetitive boilerplate code with a simple function call: the magic "log" function.

from goatl import log

goatl usage is all about the log

Usage

as a function

log("hello world")
# 2020-07-19 16:00:00,000 - goatl - INFO - hello world
log.debug("hello world?")
# 2020-07-19 16:00:00,000 - goatl - DEBUG - hello world?
log.info("do you know the answer of {} + {}?", 41, 1)
# 2020-07-19 16:00:00,000 - goatl - INFO - do you know the answer of 41 + 1?

as a method decorator

@log
def foo(x, y):
    return x + y

@log.debug
def bar():
    return "hello world"

@log.debug(return_level=log.info)
def baz(x):
    return x*2

foo(1, 2)
# ... INFO - foo called with args: (1, 2), kwargs: {}
# ... DEBUG - foo returned: 3
bar()
# ... DEBUG - bar called with args: (), kwargs: {}
# ... DEBUG - bar returned: hello world
baz(3)
# ... DEBUG - baz called with args: (3,), kwargs: {}
# ... INFO - baz returned: 6

as a class decorator

@log
class Foo:
    def __init__(self, x):
        self.x = x

    def bar(self, y):
        return self.x + y

    @log.warn
    def baz(self):
        return self.x * 2


foo = Foo(1)
# ... INFO - Instantiated Foo with args: (1,), kwargs: {}
foo.bar(2)
# ... INFO - Foo.bar called with args: (2,), kwargs: {}
# ... DEBUG - Foo.bar returned: 3
foo.baz()
# ... WARNING - Foo.baz called with args: (), kwargs: {}
# ... WARNING - Foo.baz returned: 2

configurations shortcuts

file_formatter = log.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
log.addFileHandler("foo.log", fmt=file_formatter)
log.addStreamHandler(fmt="%(levelname)s - %(message)s")
log.basicConfig(...)

logging interface #not implemented yet

I do plan to implement goatl's interaction with logging through an interface such that it will be possible to use goatl with any logging backend.

log.setBackend(logging)
log.setBackend(loguru)
logger = log.getLogger("foo")

core concepts

In order to justify the existence of goatl, it must fulfill three important core concepts:

1. Unobtrusive - it should not interfere* with the existing code.
2. Ease of use - using it should be intuitive and pythonic.
3. Clean - the amount of code added to the existing code should be minimal.

_{* - logging will always carry a performative cost, goatl will aim at keeping it to a minimum.}

means

extensive testing of goatl must be implemented to ensure that it does not interfere with the existing code. it should be tested by wrapping other popular libraries and modules with goatl. this will ensure that goatl does not interfere with the existing code. performance tests should be implemented to measure the performance cost of goatl, it should not exceed a reasonable threshold, in comparison to adding logging manually.

main features

the log function provides an easy interace for:

• out of and in context log calls
• wrapping existing functions with log calls
• wrapping existing classes with log calls
• wrapping existing modules with log calls #not implemented yet, is this even possible?
• logging configuration #not implemented yet
• support multiple logging backends #not implemented yet

all in an intuitive and pythonic way.

Releases

You can see the list of available releases on the GitHub Releases page.

License

This project is licensed under the terms of the MIT license. See LICENSE for more details.

Citation

@misc{goatl,
  author = {goatl},
  title = {goat logger},
  year = {2023},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/EytanDn/goatl}}
}