File Coverage

blib/lib/Plack/Middleware/Profiler/NYTProf.pm

Criterion	Covered	Total	%
statement	110	128	85.9
branch	29	46	63.0
condition	4	9	44.4
subroutine	37	41	90.2
pod	2	11	18.1
total	182	235	77.4

package Plack::Middleware::Profiler::NYTProf;
use strict;
use warnings;
use parent qw(Plack::Middleware);
our $VERSION = '0.17';

use Plack::Util::Accessor qw(
    enable_profile
    enable_reporting
    env_nytprof
    generate_profile_id
    profiling_result_dir
    report_dir
    nytprofhtml_path
    profiling_result_file_name
    nullfile_name
    before_profile
    after_profile
);

use File::Spec;
use Time::HiRes qw(gettimeofday);
use File::Which;

use constant PROFILE_ID       => 'psgix.profiler.nytprof.reqid';
use constant PROFILER_ENABLED => 'psgix.profiler.nytprof.enabled';

my %PROFILER_SETUPED;

my $NYTPROF_LOADED = 0;

# Devel::NYTProf requires to be loaded in a compile phase.
# So you should call this method in the BEGIN of your app.psgi with the NYTPROF environment variable.
sub preload {
    $ENV{NYTPROF} ||= _default_env();
    require Devel::NYTProf;
    DB::disable_profile();
    $NYTPROF_LOADED = 1;
}

sub _default_env { 'start=no:sigexit=int' }

sub prepare_app {
    my $self = shift;

    $self->_setup_profile_id;
    $self->_setup_profiling_file_paths;
    $self->_setup_profiling_hooks;
    $self->_setup_enable_profile;
    $self->_setup_enable_reporting;
    $self->_setup_report_dir;
    $self->_setup_nytprofhtml_path;
}

sub _setup_profiling_file_paths {
    my $self = shift;
    $self->_setup_profiling_result_dir;
    $self->_setup_profiling_result_file_name;
    $self->_setup_nullfile_name;
}

sub _setup_enable_reporting {
    my $self = shift;
    $self->enable_reporting(1) unless defined $self->enable_reporting;
}

sub _setup_enable_profile {
    my $self = shift;
    $self->enable_profile( sub {1} ) unless $self->enable_profile;
}

sub _setup_profiling_result_dir {
    my $self = shift;
    $self->profiling_result_dir( sub {'.'} )
        unless is_code_ref( $self->profiling_result_dir );
}

sub _setup_report_dir {
    my $self = shift;
    $self->report_dir( sub {'report'} )
        unless is_code_ref( $self->report_dir );
}

sub _setup_nytprofhtml_path {
    my $self = shift;
    return if $self->nytprofhtml_path;
    my $nytprofhtml_path = File::Which::which('nytprofhtml')
        or die "Could not find nytprofhtml script. Ensure it's in your path";
    $self->nytprofhtml_path($nytprofhtml_path);
}

sub _setup_profile_id {
    my $self = shift;
    $self->generate_profile_id( sub { return $$ . "-" . gettimeofday; } )
        unless is_code_ref( $self->generate_profile_id );
}

sub _setup_profiling_result_file_name {
    my $self = shift;
    $self->profiling_result_file_name(
        sub { my $id = $_[1]->{PROFILE_ID}; return "nytprof.$id.out"; } )
        unless is_code_ref( $self->profiling_result_file_name );
}

sub _setup_nullfile_name {
    my $self = shift;

    $self->nullfile_name('nytprof.null.out') unless $self->nullfile_name;
}

sub _setup_profiling_hooks {
    my $self = shift;
    $self->before_profile( sub { } )
        unless is_code_ref( $self->before_profile );
    $self->after_profile( sub { } )
        unless is_code_ref( $self->after_profile );

}

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

    $self->_setup_profiler($env);
    $self->start_profiling_if_needed($env);

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

    if ( ref($res) && ref($res) eq 'ARRAY' ) {
        $self->stop_profiling_and_report_if_needed($env);
        return $res;
    }

    Plack::Util::response_cb(
        $res,
        sub {
            my $res = shift;
            sub {
                my $chunk = shift;
                if ( !defined $chunk ) {
                    $self->stop_profiling_and_report_if_needed($env);
                    return;
                }
                return $chunk;
                }
        }
    );
}

sub start_profiling_if_needed {
    my ( $self, $env ) = @_;
    my $is_profiler_enabled = $self->enable_profile->($env);
    return unless $is_profiler_enabled;

    $env->{PROFILER_ENABLED} = 1;
    $self->before_profile->( $self, $env );
    $self->start_profiling($env);
}

sub stop_profiling_and_report_if_needed {
    my ( $self, $env ) = @_;
    my $is_profiler_enabled = $env->{PROFILER_ENABLED};
    return unless $is_profiler_enabled;

    $self->stop_profiling($env);
    $self->report($env) if $self->enable_reporting;
    $self->after_profile->( $self, $env );
}

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

    my $pid = $$;
    return if $PROFILER_SETUPED{$pid};
    $PROFILER_SETUPED{$pid} = 1;

    my $is_profiler_enabled = $self->enable_profile->($env);
    return unless $is_profiler_enabled;

    return if $NYTPROF_LOADED;

    $ENV{NYTPROF} = $ENV{NYTPROF} || $self->env_nytprof || _default_env();
    require Devel::NYTProf;
    DB::disable_profile();
    $NYTPROF_LOADED = 1;
}

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

    $env->{PROFILE_ID} = $self->generate_profile_id->( $self, $env );
    DB::enable_profile( $self->profiling_result_file_path($env) );
}

sub stop_profiling {
    DB::disable_profile();
}

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

    return unless $env->{PROFILE_ID};

    DB::enable_profile( $self->nullfile_path );
    DB::disable_profile();
    my $profiling_result_file = $self->profiling_result_file_path($env);
    return unless ( -f $profiling_result_file );
    system $self->nytprofhtml_path, "-f", $profiling_result_file,
        '-o', $self->report_dir->();
}

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

    return File::Spec->catfile(
        $self->profiling_result_dir->( $self, $env ),
        $self->profiling_result_file_name->( $self, $env )
    );
}

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

    return File::Spec->catfile( $self->profiling_result_dir->( $self, $env ),
        $self->nullfile_name );
}

sub is_code_ref {
    my $ref = shift;
    return ( ref($ref) eq 'CODE' ) ? 1 : 0;
}

sub DESTROY {
    DB::finish_profile() if defined &{"DB::finish_profile"};
}

1;

__END__