File: README

package info (click to toggle)
liblog-contextual-perl 0.008001-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 340 kB
  • sloc: perl: 681; makefile: 2
file content (574 lines) | stat: -rw-r--r-- 18,996 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
NAME
    Log::Contextual - Simple logging interface with a contextual log

VERSION
    version 0.008001

SYNOPSIS
     use Log::Contextual qw( :log :dlog set_logger with_logger );
     use Log::Contextual::SimpleLogger;
     use Log::Log4perl ':easy';
     Log::Log4perl->easy_init($DEBUG);

     my $logger  = Log::Log4perl->get_logger;

     set_logger $logger;

     log_debug { 'program started' };

     sub foo {

       my $minilogger = Log::Contextual::SimpleLogger->new({
         levels => [qw( trace debug )]
       });

       my @args = @_;

       with_logger $minilogger => sub {
         log_trace { 'foo entered' };
         my ($foo, $bar) = Dlog_trace { "params for foo: $_" } @args;
         # ...
         slog_trace 'foo left';
       };
     }

     foo();

    Beginning with version 1.008 Log::Dispatchouli also works out of the box
    with "Log::Contextual":

     use Log::Contextual qw( :log :dlog set_logger );
     use Log::Dispatchouli;
     my $ld = Log::Dispatchouli->new({
        ident     => 'slrtbrfst',
        to_stderr => 1,
        debug     => 1,
     });

     set_logger $ld;

     log_debug { 'program started' };

DESCRIPTION
    Major benefits:

    * Efficient

      The default logging functions take blocks, so if a log level is
      disabled, the block will not run:

       # the following won't run if debug is off
       log_debug { "the new count in the database is " . $rs->count };

      Similarly, the "D" prefixed methods only "Dumper" the input if the
      level is enabled.

    * Handy

      The logging functions return their arguments, so you can stick them in
      the middle of expressions:

       for (log_debug { "downloading:\n" . join qq(\n), @_ } @urls) { ... }

    * Generic

      "Log::Contextual" is an interface for all major loggers. If you log
      through "Log::Contextual" you will be able to swap underlying loggers
      later.

    * Powerful

      "Log::Contextual" chooses which logger to use based on user defined
      "CodeRef"s. Normally you don't need to know this, but you can take
      advantage of it when you need to later.

    * Scalable

      If you just want to add logging to your basic application, start with
      Log::Contextual::SimpleLogger and then as your needs grow you can
      switch to Log::Dispatchouli or Log::Dispatch or Log::Log4perl or
      whatever else.

    This module is a simple interface to extensible logging. It exists to
    abstract your logging interface so that logging is as painless as
    possible, while still allowing you to switch from one logger to another.

    It is bundled with a really basic logger, Log::Contextual::SimpleLogger,
    but in general you should use a real logger instead. For something more
    serious but not overly complicated, try Log::Dispatchouli (see
    "SYNOPSIS" for example.)

A WORK IN PROGRESS
    This module is certainly not complete, but we will not break the
    interface lightly, so I would say it's safe to use in production code.
    The main result from that at this point is that doing:

     use Log::Contextual;

    will die as we do not yet know what the defaults should be. If it turns
    out that nearly everyone uses the ":log" tag and ":dlog" is really rare,
    we'll probably make ":log" the default. But only time and usage will
    tell.

IMPORT OPTIONS
    See "SETTING DEFAULT IMPORT OPTIONS" for information on setting these
    project wide.

  -logger
    When you import this module you may use "-logger" as a shortcut for
    "set_logger", for example:

     use Log::Contextual::SimpleLogger;
     use Log::Contextual qw( :dlog ),
       -logger => Log::Contextual::SimpleLogger->new({ levels => [qw( debug )] });

    sometimes you might want to have the logger handy for other stuff, in
    which case you might try something like the following:

     my $var_log;
     BEGIN { $var_log = VarLogger->new }
     use Log::Contextual qw( :dlog ), -logger => $var_log;

  -levels
    The "-levels" import option allows you to define exactly which levels
    your logger supports. So the default, "[qw(debug trace warn info error
    fatal)]", works great for Log::Log4perl, but it doesn't support the
    levels for Log::Dispatch. But supporting those levels is as easy as
    doing

     use Log::Contextual
       -levels => [qw( debug info notice warning error critical alert emergency )];

  -package_logger
    The "-package_logger" import option is similar to the "-logger" import
    option except "-package_logger" sets the logger for the current package.

    Unlike "-default_logger", "-package_logger" cannot be overridden with
    "set_logger" or "with_logger".

     package My::Package;
     use Log::Contextual::SimpleLogger;
     use Log::Contextual qw( :log ),
       -package_logger => Log::Contextual::WarnLogger->new({
          env_prefix => 'MY_PACKAGE'
       });

    If you are interested in using this package for a module you are putting
    on CPAN we recommend Log::Contextual::WarnLogger for your package
    logger.

  -default_logger
    The "-default_logger" import option is similar to the "-logger" import
    option except "-default_logger" sets the default logger for the current
    package.

    Basically it sets the logger to be used if "set_logger" is never called;
    so

     package My::Package;
     use Log::Contextual::SimpleLogger;
     use Log::Contextual qw( :log ),
       -default_logger => Log::Contextual::WarnLogger->new({
          env_prefix => 'MY_PACKAGE'
       });

SETTING DEFAULT IMPORT OPTIONS
    Eventually you will get tired of writing the following in every single
    one of your packages:

     use Log::Log4perl;
     use Log::Log4perl ':easy';
     BEGIN { Log::Log4perl->easy_init($DEBUG) }

     use Log::Contextual -logger => Log::Log4perl->get_logger;

    You can set any of the import options for your whole project if you
    define your own "Log::Contextual" subclass as follows:

     package MyApp::Log::Contextual;

     use base 'Log::Contextual';

     use Log::Log4perl ':easy';
     Log::Log4perl->easy_init($DEBUG)

     sub arg_default_logger { $_[1] || Log::Log4perl->get_logger }
     sub arg_levels { [qw(debug trace warn info error fatal custom_level)] }
     sub default_import { ':log' }

     # or maybe instead of default_logger
     sub arg_package_logger { $_[1] }

     # and almost definitely not this, which is only here for completeness
     sub arg_logger { $_[1] }

    Note the "$_[1] ||" in "arg_default_logger". All of these methods are
    passed the values passed in from the arguments to the subclass, so you
    can either throw them away, honor them, die on usage, etc. To be clear,
    if you define your subclass, and someone uses it as follows:

     use MyApp::Log::Contextual -default_logger => $foo,
                                -levels => [qw(bar baz biff)];

    Your "arg_default_logger" method will get $foo and your "arg_levels"
    will get "[qw(bar baz biff)]";

    Additionally, the "default_import" method is what happens if a user
    tries to use your subclass with no arguments. The default just dies, but
    if you'd like to change the default to import a tag merely return the
    tags you'd like to import. So the following will all work:

     sub default_import { ':log' }

     sub default_import { ':dlog' }

     sub default_import { qw(:dlog :log ) }

    See Log::Contextual::Easy::Default for an example of a subclass of
    "Log::Contextual" that makes use of default import options.

FUNCTIONS
  set_logger
     my $logger = WarnLogger->new;
     set_logger $logger;

    Arguments: "LOGGER CODEREF"

    "set_logger" will just set the current logger to whatever you pass it.
    It expects a "CodeRef", but if you pass it something else it will wrap
    it in a "CodeRef" for you. "set_logger" is really meant only to be
    called from a top-level script. To avoid foot-shooting the function will
    warn if you call it more than once.

  with_logger
     my $logger = WarnLogger->new;
     with_logger $logger => sub {
        if (1 == 0) {
           log_fatal { 'Non Logical Universe Detected' };
        } else {
           log_info  { 'All is good' };
        }
     };

    Arguments: "LOGGER CODEREF", "CodeRef $to_execute"

    "with_logger" sets the logger for the scope of the "CodeRef"
    $to_execute. As with "set_logger", "with_logger" will wrap
    $returning_logger with a "CodeRef" if needed.

  has_logger
     my $logger = WarnLogger->new;
     set_logger $logger unless has_logger;

    Arguments: none

    "has_logger" will return true if a logger has been set.

  log_$level
    Import Tag: ":log"

    Arguments: "CodeRef $returning_message, @args"

    "log_$level" functions all work the same except that a different method
    is called on the underlying $logger object. The basic pattern is:

     sub log_$level (&@) {
       if ($logger->is_$level) {
         $logger->$level(shift->(@_));
       }
       @_
     }

    Note that the function returns it's arguments. This can be used in a
    number of ways, but often it's convenient just for partial inspection of
    passthrough data

     my @friends = log_trace {
       'friends list being generated, data from first friend: ' .
         Dumper($_[0]->TO_JSON)
     } generate_friend_list();

    If you want complete inspection of passthrough data, take a look at the
    "Dlog_$level" functions.

    Which functions are exported depends on what was passed to "-levels".
    The default (no "-levels" option passed) would export:

    log_trace
    log_debug
    log_info
    log_warn
    log_error
    log_fatal
      Note: "log_fatal" does not call "die" for you, see "EXCEPTIONS AND
      ERROR HANDLING"

  slog_$level
    Mostly the same as "log_$level", but expects a string as first argument,
    not a block. Arguments are passed through just the same, but since it's
    just a string, interpolation of arguments into it must be done manually.

     my @friends = slog_trace 'friends list being generated.', generate_friend_list();

  logS_$level
    Import Tag: ":log"

    Arguments: "CodeRef $returning_message, Item $arg"

    This is really just a special case of the "log_$level" functions. It
    forces scalar context when that is what you need. Other than that it
    works exactly same:

     my $friend = logS_trace {
       'I only have one friend: ' .  Dumper($_[0]->TO_JSON)
     } friend();

    See also: "DlogS_$level".

  slogS_$level
    Mostly the same as "logS_$level", but expects a string as first
    argument, not a block. Arguments are passed through just the same, but
    since it's just a string, interpolation of arguments into it must be
    done manually.

     my $friend = slogS_trace 'I only have one friend.', friend();

  Dlog_$level
    Import Tag: ":dlog"

    Arguments: "CodeRef $returning_message, @args"

    All of the following six functions work the same as their "log_$level"
    brethren, except they return what is passed into them and put the
    stringified (with Data::Dumper::Concise) version of their args into $_.
    This means you can do cool things like the following:

     my @nicks = Dlog_debug { "names: $_" } map $_->value, $frew->names->all;

    and the output might look something like:

     names: "fREW"
     "fRIOUX"
     "fROOH"
     "fRUE"
     "fiSMBoC"

    Which functions are exported depends on what was passed to "-levels".
    The default (no "-levels" option passed) would export:

    Dlog_trace
    Dlog_debug
    Dlog_info
    Dlog_warn
    Dlog_error
    Dlog_fatal
      Note: "Dlog_fatal" does not call "die" for you, see "EXCEPTIONS AND
      ERROR HANDLING"

  Dslog_$level
    Mostly the same as "Dlog_$level", but expects a string as first
    argument, not a block. Arguments are passed through just the same, but
    since it's just a string, no interpolation point can be used, instead
    the Dumper output is appended.

     my @nicks = Dslog_debug "names: ", map $_->value, $frew->names->all;

  DlogS_$level
    Import Tag: ":dlog"

    Arguments: "CodeRef $returning_message, Item $arg"

    Like "logS_$level", these functions are a special case of "Dlog_$level".
    They only take a single scalar after the $returning_message instead of
    slurping up (and also setting "wantarray") all the @args

     my $pals_rs = DlogS_debug { "pals resultset: $_" }
       $schema->resultset('Pals')->search({ perlers => 1 });

  DslogS_$level
    Mostly the same as "DlogS_$level", but expects a string as first
    argument, not a block. Arguments are passed through just the same, but
    since it's just a string, no interpolation point can be used, instead
    the Dumper output is appended.

     my $pals_rs = DslogS_debug "pals resultset: ",
       $schema->resultset('Pals')->search({ perlers => 1 });

LOGGER CODEREF
    Anywhere a logger object can be passed, a coderef is accepted. This is
    so that the user can use different logger objects based on runtime
    information. The logger coderef is passed the package of the caller, and
    the caller level the coderef needs to use if it wants more caller
    information. The latter is in a hashref to allow for more options in the
    future.

    Here is a basic example of a logger that exploits "caller" to reproduce
    the output of "warn" with a logger:

     my @caller_info;
     my $var_log = Log::Contextual::SimpleLogger->new({
        levels  => [qw(trace debug info warn error fatal)],
        coderef => sub { chomp($_[0]); warn "$_[0] at $caller_info[1] line $caller_info[2].\n" }
     });
     my $warn_faker = sub {
        my ($package, $args) = @_;
        @caller_info = caller($args->{caller_level});
        $var_log
     };
     set_logger($warn_faker);
     log_debug { 'test' };

    The following is an example that uses the information passed to the
    logger coderef. It sets the global logger to $l3, the logger for the
    "A1" package to $l1, except the "lol" method in "A1" which uses the $l2
    logger and lastly the logger for the "A2" package to $l2.

    Note that it increases the caller level as it dispatches based on where
    the caller of the log function, not the log function itself.

     my $complex_dispatcher = do {

        my $l1 = ...;
        my $l2 = ...;
        my $l3 = ...;

        my %registry = (
           -logger => $l3,
           A1 => {
              -logger => $l1,
              lol     => $l2,
           },
           A2 => { -logger => $l2 },
        );

        sub {
           my ( $package, $info ) = @_;

           my $logger = $registry{'-logger'};
           if (my $r = $registry{$package}) {
              $logger = $r->{'-logger'} if $r->{'-logger'};
              my (undef, undef, undef, $sub) = caller($info->{caller_level} + 1);
              $sub =~ s/^\Q$package\E:://g;
              $logger = $r->{$sub} if $r->{$sub};
           }
           return $logger;
        }
     };

     set_logger $complex_dispatcher;

LOGGER INTERFACE
    Because this module is ultimately pretty looking glue (glittery?) with
    the awesome benefit of the Contextual part, users will often want to
    make their favorite logger work with it. The following are the methods
    that should be implemented in the logger:

     is_trace
     is_debug
     is_info
     is_warn
     is_error
     is_fatal
     trace
     debug
     info
     warn
     error
     fatal

    The first six merely need to return true if that level is enabled. The
    latter six take the results of whatever the user returned from their
    coderef and log them. For a basic example see
    Log::Contextual::SimpleLogger.

LOG ROUTING
    In between the loggers and the log functions is a log router that is
    responsible for finding a logger to handle the log event and passing the
    log information to the logger. This relationship is described in the
    documentation for "Log::Contextual::Role::Router".

    "Log::Contextual" and packages that extend it will by default share a
    router singleton that implements the with_logger() and set_logger()
    functions and also respects the -logger, -package_logger, and
    -default_logger import options with their associated default value
    functions. The router singleton is available as the return value of the
    router() function. Users of Log::Contextual may overload router() to
    return instances of custom log routers that could for example work with
    loggers that use a different interface.

EXCEPTIONS AND ERROR HANDLING
    "Log::Contextual", by design, does not intentionally invoke "die" on
    your behalf(*see footnote*) for "log_fatal".

    Logging events are characterized as information, not flow control, and
    conflating the two results in negative design anti-patterns.

    As such, "log_fatal" would at be better used to communicate information
    about a *future* failure, for example:

      if ( condition ) {
        log_fatal { "Bad Condition is true" };
        die My::Exception->new();
      }

    This has a number of benefits:

    *   You're more likely to want to use useful Exception Objects and flow
        control instead of cheating with log messages.

    *   You're less likely to run a risk of losing what the actual problem
        was when some error occurs in your creation of the Exception Object

    *   You're less likely to run the risk of losing important log context
        due to exceptions occurring mid way through "die" unwinding and
        "exit" global destruction.

    If you're still too lazy to use exceptions, then you can do what you
    probably want as follows:

      if ( ... ) {
        log_fatal { "Bad condition is true" };
        die "Bad condtion is true";
      }

    Or for ":dlog" style:

      use Data::Dumper::Consise qw( Dumper );
      if ( ... ) {
        # Dlog_fatal but not
        my $reason = "Bad condtion is true because: " . Dumper($thing);
        log_fatal { $reason };
        die $reason;
      }

  footnote
    The underlying behaviour of "log_fatal" is dependent on the backing
    library.

    All the Loggers shipping with "Log::Contextual" behave this way, as do
    many of the supported loggers, like "Log::Log4perl". However, not all
    loggers work this way, and one must be careful.

    "Log::Dispatch" doesn't support implementing "log_fatal" at all

    "Log::Dispatchouli" implements "log_fatal" using "die" ( via Carp )

CONTRIBUTORS
    kentnl - Kent Fredric <kentfredric@gmail.com>

    triddle - Tyler Riddle <t.riddle@shadowcat.co.uk>

    voj - Jakob Voß <voss@gbv.de>

DESIGNER
    mst - Matt S. Trout <mst@shadowcat.co.uk>

AUTHOR
    Arthur Axel "fREW" Schmidt <frioux+cpan@gmail.com>

COPYRIGHT AND LICENSE
    This software is copyright (c) 2018 by Arthur Axel "fREW" Schmidt.

    This is free software; you can redistribute it and/or modify it under
    the same terms as the Perl 5 programming language system itself.