File Coverage

blib/lib/Plack/Middleware/XRay.pm

Criterion	Covered	Total	%
statement	50	52	96.1
branch	18	22	81.8
condition	2	2	100.0
subroutine	10	10	100.0
pod	1	2	50.0
total	81	88	92.0

package Plack::Middleware::XRay;

use 5.012000;
use strict;
use warnings;
use parent "Plack::Middleware";

use AWS::XRay qw/ capture_from /;
use Time::HiRes ();

our $VERSION           = "0.05";
our $TRACE_HEADER_NAME = "X-Amzn-Trace-ID";
(my $trace_header_key  = uc("HTTP_${TRACE_HEADER_NAME}")) =~ s/-/_/g;

sub call {
    my ($self, $env) = @_;

    local $AWS::XRay::SAMPLER = $AWS::XRay::SAMPLER;
    if (ref $self->{sampler} eq "CODE") {
        $AWS::XRay::SAMPLER = sub { $self->{sampler}->($env) };
    }
    else {
        AWS::XRay->sampling_rate($self->{sampling_rate} // 1);
    }

    if ($self->{response_filter}) {
        AWS::XRay->auto_flush(0);
    }

    my $t0 = [ Time::HiRes::gettimeofday ];
    my $res = capture_from $env->{$trace_header_key}, $self->{name}, sub {
        my $segment = shift;

        # fill annotations and metadata
        for my $key (qw/ annotations metadata /) {
            my $code = $self->{"${key}_builder"};
            next unless ref $code eq "CODE";
            $segment->{$key} = {
                %{$self->{$key} || {}},
                %{$code->($env)},
            }
        }

        # HTTP request info
        $segment->{http} = {
            request => {
                method     => $env->{REQUEST_METHOD},
                url        => url($env),
                client_ip  => $env->{REMOTE_ADDR},
                user_agent => $env->{HTTP_USER_AGENT},
            },
        };

        # Run app
        my $res = eval {
            $self->app->($env);
        };
        my $error = $@;
        if ($error) {
            warn $error;
            $res = [
                500,
                ["Content-Type", "text/plain"],
                ["Internal Server Error"],
            ];
        }

        # HTTP response info
        $segment->{http}->{response}->{status} = $res->[0];
        my $status_key =
            $res->[0] >= 500 ? "fault"
          : $res->[0] == 429 ? "throttle"
          : $res->[0] >= 400 ? "error"
          :                    undef;
        $segment->{$status_key} = Types::Serialiser::true if $status_key;

        return $res;
    };

    if (my $func = $self->{response_filter}) {
        my $elapsed = Time::HiRes::tv_interval($t0);
        $func->($env, $res, $elapsed) && AWS::XRay->sock->flush();
        AWS::XRay->sock->close();
    }
    return $res;
}

sub url {
    my $env = shift;
    return sprintf(
        "%s://%s%s",
        $env->{"psgi.url_scheme"},
        $env->{HTTP_HOST},
        $env->{REQUEST_URI},
    );
}

1;
__END__