Twiggy

Twiggy is een vroeg stadium project om een ​​meer Pythonic logging pakket bouwen.
Gebruik:
Maak vertoning werk:
>>> Import sys; sys.stderr = sys.stdout
De installatie is eenvoudig
In je main.py:
>>> Import twiggy
>>> Twiggy.quick_setup ()
Logging Berichten
>>> Van twiggy import *
Belangrijkste interface is het de magie log:
>>> Log #doctest: + Ellipsis

Het werkt uit de doos, met behulp van standaard niveaus:
>>> Log.debug ('Je mag niet schelen')
DEBUG: Je mag niet schelen
>>> Log.error ('OMFG! Broek in brand!')
FOUT: OMFG! Broek in brand!
Het ondersteunt een groot aantal opmaak strings, in gebreke gebleven om nieuwe-stijl:
>>> Log.info ('ik draag {0} op mijn {}, waar', 'broek', waarbij = 'benen')
INFO: Ik draag broek op mijn benen
Oude stijl werkt prima hoewel:
>>> Log.options (style = 'procent'). Info ('I like% s "," bikes ")
INFO: Ik hou van fietsen
Zoals te doen templates:
>>> Log.options (style = 'dollar'). Info ('$ wat kill', wat = 'Cars')
INFO: Auto's doden
U kunt de naam van uw loggers:
>>> Mylog = log.name ('Alfredo')
>>> Mylog.debug ('hallo')
DEBUG: alfredo: hello
Maar de naam heeft geen relatie met het object; het is gewoon voor menselijk gebruik:
>>> Mylog is log.name ('Alfredo')
Vals
Emitting Berichten
Emitters losjes gekoppelde:
>>> Twiggy.emitters #doctest: + Ellipsis
{'*': }
U kunt een min_level op Emitters set:
>>> Twiggy.emitters ['*']. Min_level = twiggy.Levels.INFO
>>> Log.debug ("Help, help ik word onderdrukt")
>>> Log.info ("Ik ben nog niet helemaal dood")
INFO: Ik ben nog niet helemaal dood
U kunt filteren op reguliere expressies, of met willekeurige functies:
>>> Twiggy.emitters ['*']. Filter = ". * Broek. *"
>>> Log.info ("Kreeg mijn {0} op", "broek")
INFO: Kreeg mijn broek op
>>> Log.info ("Kreeg mijn {0} op", "overhemd")
Laten we reset al dat:
>>> Twiggy.emitters ['*']. Filter = True
>>> Twiggy.emitters ['*']. Min_level = twiggy.Levels.DEBUG
Beter uitgang
Nieuwe regels worden onderdrukt standaard; die kan worden uitgeschakeld per-bericht:
>>> Log.info ('user ninput nannoys Nus')
INFO: gebruiker ninput nannoys Nus
>>> Log.options (suppress_newlines = false) .info ('we ndeal')
INFO: we
transactie
Uitzonderingen worden voorafgegaan. Kan ook exc_info passeren. Gebruik ' n' als voorvoegsel te vouwen in een enkele regel:
>>> Try:
... 1/0
... Behalve:
... Log.trace ('error') waarschuwing ('oh noes ") #doctest:. + Ellipsis
WAARSCHUWING: oh noes
TRACE Traceback (meest recente oproep vorige):
TRACE File "", lijn 2, in
TRACE 1/0
TRACE ZeroDivisionError: integer deling of modulo door nul
Method Chaining
Ik hou van deze vastgeketend stijl veel.
>>> Log.name ('benito'). Info ('hi there')
INFO: benito: hi there
Het maakt gestructureerde logging eenvoudig:
>>> Log.fields (wegen = 42) .info ('Going voor een wandeling')
INFO: paden = 42: gaan voor een wandeling
Short cut. Geweldig voor runtime statistieken verzamelen.
>>> Log.struct (wegen = 42, dolfijnen = 'dankbaar')
INFO: dolfijnen = dankbaar: paden = 42:
Gedeeltelijke binding kan nuttig zijn voor webapps:
>>> Per_request_log = log.fields (request_id = '12345')
>>> Per_request_log.fields (rijen = 100, user = 'frank'). Info ('frobnicating databank')
INFO: request_id = 12345: rijen = 100: user = frank: frobnicating databank
>>> Per_request_log.fields (bytes = 5678) .info ('verzenden pagina boven tubes')
INFO: bytes = 5678: request_id = 12345: verzenden pagina boven buizen
Geketend stijl is geweldig:
>>> Log.name ('donjuan'). Velden (broek = 'sexy'). Info ("hallo, {} die willen {wat}?", Die = 'ladies', wat = 'dans')
INFO: donjuan: broek = sexy: hello, dames willen dansen?
Dynamic!
Elke functies in args / velden worden genoemd en de waarde gesubstitueerd:
>>> Import os
>>> Van twiggy.lib import thread_name
>>> Thread_name ()
'MainThread'
>>> Log.fields (pid = os.getpid) .info ("Ik ben in thread {0}", thread_name) #doctest: + Ellipsis
INFO: pid = 1076: Ik ben in thread MainThread
Dit kan handig zijn met gedeeltelijk gebonden houthakkers, die laat het ons doen wat coole dingen:
>>> Class ThreadTracker (object):
... Def __init __ (zelf, obj):
... Zelf .__ obj = obj
... # Een gedeeltelijk gebonden logger
... Zelf .__ log = log.name ("tracker"). Velden (obj_id = id (obj), draad = thread_name)
... Zelf .__ log.debug ("begon het bijhouden")
... Def __getattr __ (zelf, attr):
... Zelf .__ log.debug ("toegankelijk {0}", attr)
... Return getattr (zelf .__ obj, attr)
...
>>> Klasse Bos (object):
... Passeren
...
>>> Foo = Bunch ()
>>> Foo.bar = 42
>>> Gevolgd = ThreadTracker (foo)
DEBUG: tracker: obj_id = 14063980: draad = MainThread: begonnen met het bijhouden
>>> Tracked.bar
DEBUG: tracker: obj_id = 14063980: draad = MainThread: toegankelijk bar
42
>>> Import threading
>>> T = threading.Thread (target = lambda: tracked.bar * 2, name = "TheDoubler")
>>> T.start ()
DEBUG: tracker: obj_id = 14063980: draad = TheDoubler: toegankelijk bar
Als je echt wilt een callable, repr inloggen () het of wikkel het in lambda.
Optimalisering
Als een optimalisatie kan een min_level worden ingesteld op loggers:
>>> Mylog.min_level = twiggy.Levels.INFO
>>> Mylog.info ("Je ziet dit")
INFO: alfredo: Je ziet dit
>>> Mylog.debug ("Dit is verborgen")
Ze nemen ook een filter dat werkt op format_spec. De use case wordt efficiënt afsluiten van bepaalde berichten in een bibliotheek die iets stoms doet:
>>> Mylog.filter = lambda s: "shenanigans" niet in s
>>> Mylog.info ("Starten onnozelheid")
INFO: alfredo: vanaf onnozelheid
>>> For i in xrange (3): # voor grote waarden van 3
... Mylog.info ("Ik noem shenanigans!")
>>> Mylog.info ("End onnozelheid")
INFO: alfredo: End onnozelheid

Eisen

• Python