https://github.com/jhthorsen/mojolicious-plugin-logf

Plugin for logging datastructures using sprintf
https://github.com/jhthorsen/mojolicious-plugin-logf

Last synced: 27 days ago
JSON representation

Plugin for logging datastructures using sprintf

• Host: GitHub
• URL: https://github.com/jhthorsen/mojolicious-plugin-logf
• Owner: jhthorsen
• Created: 2014-06-12T07:18:51.000Z (over 10 years ago)
• Default Branch: master
• Last Pushed: 2016-05-03T12:24:06.000Z (over 8 years ago)
• Last Synced: 2024-10-16T11:58:32.279Z (3 months ago)
• Language: Perl
• Size: 22.5 KB
• Stars: 0
• Watchers: 3
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README
  • Changelog: Changes

Awesome Lists containing this project

README

        
NAME

    Mojolicious::Plugin::Logf - Plugin for logging datastructures using

    sprintf

VERSION

    0.10

DESCRIPTION

    Mojolicious::Plugin::Logf is a plugin which will log complex

    datastructures and avoid "unitialized" warnings. This plugin use

    Mojo::Log or whatever "log" in Mojo is set to, to do the actual logging.

SYNOPSIS

      use Mojolicious::Lite;

      plugin logf => {rfc3339 => 1};

      get "/" => sub {

        my $c = shift;

        $c->logf(info => 'request: %s', $self->req->params->to_hash);

        $c->render(text => "cool!");

      };

    Setting "rfc3339" to "1" will make the log look like this:

      [2016-02-19T13:05:37Z] [info] Some log message

COPY/PASTE CODE

    If you think it's a waste to depend on this module, you can copy paste

    the code below to get the same functionality as the "logf" helper:

      helper logf => sub {

        my ($c, $level, $format) = (shift, shift, shift);

        my $log = $c->app->log;

        return $c unless $log->is_level($level);

        my @args = map { ref $_ eq 'CODE' ? $_->() : $_ } @_;

        local $Data::Dumper::Indent   = 0;

        local $Data::Dumper::Maxdepth = $Data::Dumper::Maxdepth || 2;

        local $Data::Dumper::Sortkeys = 1;

        local $Data::Dumper::Terse    = 1;

        for (@args) {

          $_

            = !defined($_) ?  "__UNDEF__" 

            : overload::Method($_, q("")) ? "$_"

            : ref($_) ? Data::Dumper::Dumper($_)

            :           $_;

        }

        $log->$level(sprintf $format, @args);

        return $c;

      };

    Note: The code above is generated and tested from the original source

    code, but it will more difficult to get updates and bug fixes.

HELPERS

  logf

      $self = $c->logf;

      $c = $c->logf($level => $format, @args);

    Logs a string formatted by the usual "printf" conventions of the C

    library function "sprintf". $level need to be a valid Mojo::Log level.

    @args will be converted using "flatten".

    Calling this method without any arguments will return $self (an instance

    of this plugin), allowing you to call "flatten":

      @args_as_strings = $c->logf->flatten(@args);

METHODS

  flatten

      @args_as_strings = $self->flatten(@args);

    Used to convert input @args using these rules:

    *   Scalar

        No rule applied.

    *   Code ref

        A code ref will be called, and the list of return values will be

        flattened. The code below will not calculate the request params,

        unless the log level is "debug":

          $c->logf(debug => 'request: %s', sub {$c->req->params->to_hash});

    *   Object with string overloading

        Will be coverted to a string using the string overloading function.

    *   Data structure or object

        Will be serialized using Data::Dumper with these settings:

          $Data::Dumper::Indent = 0;

          $Data::Dumper::Maxdepth = $Data::Dumper::Maxdepth || 2;

          $Data::Dumper::Sortkeys = 1;

          $Data::Dumper::Terse = 1;

        NOTE! These settings might change, but will always do its best to

        serialize the object into one line. $Data::Dumper::Maxdepth is used

        to avoid dumping large nested objects. Set this variable if you need

        deeper logging. Example:

          local $Data::Dumper::Maxdepth = 1000;

          $c->logf(info => 'Deep structure: %s', $some_object);

    *   Undefined value

        Will be logged as "__UNDEF__". This value can be changed by setting

        the global environment variable "MOJO_LOGF_UNDEF" before loading

        this plugin.

  register

    Will register the "logf" helper in the application

COPYRIGHT AND LICENSE

    Copyright (C) 2014, Jan Henning Thorsen

    This program is free software, you can redistribute it and/or modify it

    under the terms of the Artistic License version 2.0.

AUTHOR

    Jan Henning Thorsen - "[email protected]"