File Coverage

blib/lib/Plack/Middleware/PrettyException.pm

Criterion	Covered	Total	%
statement	104	111	93.6
branch	33	40	82.5
condition	23	30	76.6
subroutine	14	14	100.0
pod	1	2	50.0
total	175	197	88.8

package Plack::Middleware::PrettyException;

# ABSTRACT: Capture exceptions and present them as HTML or JSON

our $VERSION = '1.010'; # VERSION

use 5.010;
use strict;
use warnings;
use parent qw(Plack::Middleware);
use Plack::Util;
use Plack::Util::Accessor qw(force_json);
use HTTP::Headers;
use JSON::MaybeXS qw(encode_json);
use HTTP::Status qw(is_error);
use Scalar::Util 'blessed';
use Log::Any qw($log);

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

    my $r;
    my $error;
    my $exception;
    my $died = 0;
    eval {
        $r = $self->app->($env);
        1;
    } or do {
        my $e = $@;
        $died = 1;
        if ( blessed($e) ) {
            $exception = $e;
            if ( $e->can('message') ) {
                $error = $e->message;
            }
            else {
                $error = '' . $e;
            }
            $r->[0] =
                  $e->can('status_code') ? $e->status_code
                : $e->can('http_status') ? $e->http_status
                :                          500;
            $r->[0] ||= 500;

            if ( $r->[0] =~ /^3/ && $e->can('location') ) {
                push( @{ $r->[1] }, Location => $e->location );
                push( @{ $r->[2] }, $e->location ) unless $r->[2];
            }

        }
        else {
            $r->[0] = 500;
            $error = $e;
        }
    };

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

            if ( !$died && !is_error( $r->[0] ) ) {

                # all is ok!
                return;
            }
            if ( $r->[0] =~ /^3/ ) {

                # it's a redirect
                return;
            }

            # there was an error!

            unless ($error) {
                my $body = $r->[2] || 'error not found in body';
                $error = ref($body) eq 'ARRAY' ? join( '', @$body ) : $body;
            }

            my $location = join( '',
                map { $env->{$_} } qw(HTTP_HOST SCRIPT_NAME PATH_INFO) );
            $log->error( $location . ': ' . $error );

            my $orig_headers = HTTP::Headers->new( @{ $r->[1] } );
            my $err_headers = Plack::Util::headers( [] );
            my $err_body;

            # it already is JSON, so return that
            if ( $orig_headers->content_type =~ m{application/json}i ) {
                return;
            }

            # force json, or client requested JSON, so render errors as JSON
            if ($self->force_json
                || ( exists $env->{HTTP_ACCEPT}
                    && $env->{HTTP_ACCEPT} =~ m{application/json}i )
                ) {
                $err_headers->set( 'content-type' => 'application/json' );
                my $err_payload = { status => 'error', message => "" . $error };
                if ($exception && $exception->can('does')) {
                    if ($exception->does('Throwable::X')) {
                        my $payload = $exception->payload;
                        while (my ($k, $v) = each %$payload) {
                            $err_payload->{$k} = $v;
                        }
                        $err_payload->{ident} = $exception->ident;
                    }
                }

                $err_body = encode_json( $err_payload );
            }

            # return HTML as default
            else {
                $err_headers->set(
                    'content-type' => 'text/html;charset=utf-8' );
                $err_body = $self->render_html_error( $r->[0], $error, $exception, $env );
            }
            $r->[1] = $err_headers->headers;
            $r->[2] = [$err_body];
            return;
        }
    );
}

sub render_html_error {
    my ( $self, $status, $error, $exception, $env ) = @_;

    $status ||= 'unknown HTTP status code';
    $error  ||= 'unknown error';

    my $more='';
    if ($exception && $exception->can('does')) {
        my @more;
        if ($exception->does('Throwable::X')) {
            push(@more, "".$exception->ident."");
            push(@more, "".($exception->message || 'unknown exception message')."");
            my $payload = $exception->payload;
            while (my ($k, $v) = each %$payload) {
                if (ref($v)) {
                    if (ref($v) eq 'ARRAY') {
                        push(@more,sprintf("%s:", $k ));
                        foreach my $sv (@$v) {
                            push(@more,sprintf("%s", $sv ));
                        }
                        push(@more,sprintf(""));
                    }
                    else {
                        push(@more,sprintf("%s which is an unhandled ref of %s", $k, ref($v)));
                    }
                }
                else {
                    push(@more,sprintf("%s: %s", $k, $v // ''));
                }
            }
        }
        if (@more) {
            $more=''.join("\n",@more).'';
        }
    }

    return <<"UGLYERROR";

  Error $status

    Error $status
    $error
    $more


UGLYERROR
}

1;

__END__