File Coverage

blib/lib/Plack/Middleware/StatsPerRequest.pm

Criterion	Covered	Total	%
statement	79	80	98.7
branch	21	22	95.4
condition	10	14	71.4
subroutine	14	14	100.0
pod	3	3	100.0
total	127	133	95.4

package Plack::Middleware::StatsPerRequest;

# ABSTRACT: Measure HTTP stats on each request

our $VERSION = '0.901';

use strict;
use warnings;
use 5.010;
use Time::HiRes qw();

use parent 'Plack::Middleware';
use Plack::Util::Accessor
    qw( app_name metric_name path_cleanups add_headers has_headers long_request );
use Plack::Request;
use Log::Any qw($log);
use Measure::Everything 1.002 qw($stats);
use HTTP::Headers::Fast;

sub prepare_app {
    my $self = shift;

    $self->app_name('unknown')         unless $self->app_name;
    $self->metric_name('http_request') unless $self->metric_name;
    $self->path_cleanups( [ \&replace_idish ] ) unless $self->path_cleanups;
    $self->long_request(5) unless defined $self->long_request;
    foreach my $check (qw(add_headers has_headers)) {
        my $val = $self->$check;
        if ( $val && ref($val) ne 'ARRAY' ) {
            $log->warn(
                "Plack::Middleware::StatsPerRequest $check has to be an ARRAYREF, ignoring $val"
            );
            $self->$check(undef);
        }
    }
}

sub call {
    my $self = shift;
    my $env  = shift;

    my $t0 = [Time::HiRes::gettimeofday];

    my $res = $self->app->($env);

    return Plack::Util::response_cb(
        $res,
        sub {
            my $res = shift;
            my $req;

            my $elapsed = Time::HiRes::tv_interval($t0);
            $elapsed = sprintf( '%5f', $elapsed ) if $elapsed < .0001;

            my $path = $env->{PATH_INFO};
            foreach my $callback ( @{ $self->path_cleanups } ) {
                $path = $callback->($path);
            }

            my %tags = (
                status => $res->[0],
                method => $env->{REQUEST_METHOD},
                app    => $self->app_name,
                path   => $path,
            );
            if ( my $headers_to_add = $self->add_headers ) {
                $req = Plack::Request->new($env);
                foreach my $header (@$headers_to_add) {
                    $tags{ 'header_' . lc($header) } = $req->header($header)
                        // 'not_set';
                }
            }
            if ( my $has_headers = $self->has_headers ) {
                $req ||= Plack::Request->new($env);
                foreach my $header (@$has_headers) {
                    $tags{ 'has_header_' . lc($header) } =
                        $req->header($header) ? 1 : 0;
                }
            }

            eval {
                $stats->write( $self->metric_name,
                    { request_time => $elapsed, hit => 1 }, \%tags );
                if ( $self->long_request && $elapsed > $self->long_request ) {
                    $req ||= Plack::Request->new($env);
                    $log->warnf( "Long request, took %f: %s %s",
                        $elapsed, $req->method, $req->request_uri );
                }
            };
            if ($@) {
                $log->errorf( "Could not write stats: %s", $@ );
            }
        }
    );
}


sub replace_idish {
    my $path = shift;
    $path = lc( $path . '/' );

    $path =~ s{/[a-f0-9\-.]+\@[a-z0-9\-.]+/}{/:msgid/}g;
    $path =~ s{/[a-f0-9]+\/[a-f0-9\/]+/}{/:hexpath/}g;

    $path =~ s([a-f0-9]{40})(:sha1)g;
    $path =~
        s([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})(:uuid)g;
    $path =~ s(\d{6,})(:int)g;
    $path =~ s{\d+x\d+}{:imgdim}g;

    $path =~ s{/\d+/}{/:int/}g;
    $path =~ s(/[^/]{55,}/)(/:long/)g;
    $path =~ s(/[a-f0-9\-]{8,}/)(/:hex/)g;

    return substr( $path, 0, -1 );
}

"42nd birthday release";

__END__