File Coverage

blib/lib/Plack/Middleware/HealthCheck.pm

Criterion	Covered	Total	%
statement	79	79	100.0
branch	35	36	97.2
condition	9	10	90.0
subroutine	16	16	100.0
pod	5	5	100.0
total	144	146	98.6

package Plack::Middleware::HealthCheck;

# ABSTRACT: A health check endpoint for your Plack app
use version;
our $VERSION = 'v0.0.5'; # VERSION

use 5.010;
use strict;
use warnings;
use parent 'Plack::Middleware';
use Plack::Request;
use Plack::Util::Accessor qw(
    health_check
    health_check_paths
    allowed_params
);

use Carp;
use JSON         ();
use Scalar::Util ();

sub new {
    my ( $class, @args ) = @_;
    my %params = @args == 1
        && Scalar::Util::reftype $args[0] eq 'HASH' ? %{ $args[0] } : @args;

    if ( $params{health_check} ) {
        croak "health_check doesn't seem like a HealthCheck"
            unless do { local $@; eval { local $SIG{__DIE__};
                $params{health_check}->can('check') } };
    }
    else {
        croak "health_check parameter required";
    }

    # Adding default params if none specified
    $params{allowed_params} = [qw< runtime >]
        unless exists $params{allowed_params};

    # custom query param filter validation
    my $error = "HealthCheck allowed_params must be an arrayref of strings";
    my $ref   = Scalar::Util::reftype $params{allowed_params};

    if ( !$ref ) {    # someone sent a scalar; massage it
        $params{allowed_params} = [ $params{allowed_params} ];
    }
    elsif ( $ref ne 'ARRAY' ) {
        croak "$error; found $ref";
    }

    foreach my $param ( @{ $params{allowed_params} } ) {
        if ( my $ref = Scalar::Util::reftype $param ) {
            croak "$error; found $ref value";
        }
        elsif ( lc $param eq 'env' ) {
            croak "Cannot overload \%env params";
        }
    }

    return $class->SUPER::new(
        health_check_paths => ['/healthz'],
        %params,
    );
}

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

    return $self->serve_health_check($env)
        if $self->should_serve_health_check($env);

    return $self->app->($env);
}

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

    my $path = $env->{'PATH_INFO'};
    foreach ( @{ $self->health_check_paths || [] } ) {
        return 1 if $path eq $_;
    }

    return 0;
}

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

    my $req            = Plack::Request->new($env);
    my $query_params   = $req->query_parameters;         # a Hash::MultiValue
    my $allowed_params = $self->allowed_params || [];    # an array

    my %check_params = ( env => $env );

    foreach my $param ( @{$allowed_params}, 'tags' ) {
        if( exists $query_params->{$param} ){
            $check_params{$param} = [ $query_params->get_all($param) ]
                if exists $query_params->{$param};
        }
    }

    # turn on runtime if pretty and make param value scalar not array
    if ( exists $check_params{runtime} ) {
        $check_params{runtime}
            = $check_params{runtime}[0] eq '' ? 1 : $check_params{runtime}[0];
    }
    elsif ( exists $req->query_parameters->{pretty} ) {
        $check_params{runtime} = 1;
    }

    local $SIG{__WARN__} = sub { $env->{'psgi.errors'}->print($_) for @_ };
    return $self->health_check_response(
        $self->health_check->check(%check_params), $req );
}

sub health_check_response {
    my ( $self, $result, $req ) = @_;
    my $json = JSON->new->utf8;
    $json->canonical->pretty
        if $req and exists $req->query_parameters->{pretty};
    return [
        ( $result->{status} || '' ) eq 'OK' ? 200 : 503,
        [ 'Content-Type' => 'application/json; charset=utf-8' ],
        [ $json->encode($result) ] ];
}

1;

__END__