Error trace

Oops at eg/dot-psgi/error.psgi line 2.

in Plack::Middleware::StackTrace::__ANON__ at eg/dot-psgi/error.psgi line 2

    1: sub { my $x = "bar"; my $y = [1,2,3]; my $z = { x => 1 }; my @y = qw(foo bar); my %z = (x => 1, y => 2);
    2:       do { die "Oops" }; return [ 200, [ 'Content-Type' => 'text/html' ], [ "Hello" ] ] };

Show lexical variables

my $x = "bar";
my $y = [1, 2, 3];
my $z = { "x" => 1 };
my %z = ( "x" => 1, "y" => 2 );
my @y = ("foo", "bar");

in Plack::Util::__ANON__ at lib/Plack/Middleware/StackTrace.pm line 29

   26: 
   27:     my $res = do {
   28:         local $@;
   29:         eval { $self->app->($env) };
   30:     };
   31: 
   32:     if (!$res && $trace) {

Show lexical variables

my $env = {
  HTTP_ACCEPT         => "*/*",
  HTTP_HOST           => "localhost:8080",
  HTTP_USER_AGENT     => "curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3",
  PATH_INFO           => "/",
  QUERY_STRING        => "",
  REMOTE_ADDR         => "127.0.0.1",
  REQUEST_METHOD      => "GET",
  REQUEST_URI         => "/",
  SCRIPT_NAME         => "",
  SERVER_NAME         => 0,
  SERVER_PORT         => 8080,
  SERVER_PROTOCOL     => "HTTP/1.1",
  "psgi.errors"       => *main::STDERR,
  "psgi.input"        => \*Plack::Server::Standalone::$input,
  "psgi.multiprocess" => "",
  "psgi.multithread"  => "",
  "psgi.run_once"     => "",
  "psgi.url_scheme"   => "http",
  "psgi.version"      => [1, 0],
};
my $self = bless({ app => sub { "???" } }, "Plack::Middleware::StackTrace");
my $trace = do {
  require Symbol;
  my $a = bless({
    frames  => [
                 bless({
                   args             => ["Devel::StackTrace::WithLexicals"],
                   bitmask          => "UUUUUUUUUUUU\25",
                   evaltext         => undef,
                   filename         => "lib/Plack/Middleware/StackTrace.pm",
                   hasargs          => 1,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => {
                                         "\$env"   => \{
                                                        HTTP_ACCEPT         => "*/*",
                                                        HTTP_HOST           => "localhost:8080",
                                                        HTTP_USER_AGENT     => "curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3",
                                                        PATH_INFO           => "/",
                                                        QUERY_STRING        => "",
                                                        REMOTE_ADDR         => "127.0.0.1",
                                                        REQUEST_METHOD      => "GET",
                                                        REQUEST_URI         => "/",
                                                        SCRIPT_NAME         => "",
                                                        SERVER_NAME         => 0,
                                                        SERVER_PORT         => 8080,
                                                        SERVER_PROTOCOL     => "HTTP/1.1",
                                                        "psgi.errors"       => *main::STDERR,
                                                        "psgi.input"        => \*Plack::Server::Standalone::$input,
                                                        "psgi.multiprocess" => "",
                                                        "psgi.multithread"  => "",
                                                        "psgi.run_once"     => "",
                                                        "psgi.url_scheme"   => "http",
                                                        "psgi.version"      => [1, 0],
                                                      },
                                         "\$self"  => \bless({ app => sub { "???" } }, "Plack::Middleware::StackTrace"),
                                         "\$trace" => \do{my $fix},
                                       },
                   line             => 23,
                   max_arg_length   => undef,
                   "package"        => "Plack::Middleware::StackTrace",
                   respect_overload => undef,
                   subroutine       => "Devel::StackTrace::new",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => ["Oops at eg/dot-psgi/error.psgi line 2.\n"],
                   bitmask          => "\0\0\0\0\0\0\0\0\0\0\0\0",
                   evaltext         => undef,
                   filename         => "eg/dot-psgi/error.psgi",
                   hasargs          => 1,
                   hints            => 0,
                   is_require       => undef,
                   lexicals         => {
                                         "\$x" => \"bar",
                                         "\$y" => \[1, 2, 3],
                                         "\$z" => \{ "x" => 1 },
                                         "%z"  => { "x" => 1, "y" => 2 },
                                         "\@y" => ["foo", "bar"],
                                       },
                   line             => 2,
                   max_arg_length   => undef,
                   "package"        => "Plack::Util",
                   respect_overload => undef,
                   subroutine       => "Plack::Middleware::StackTrace::__ANON__",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => ['fix'],
                   bitmask          => "UUUUUUUUUUUU\25",
                   evaltext         => undef,
                   filename         => "lib/Plack/Middleware/StackTrace.pm",
                   hasargs          => 1,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => { "\$env" => 'fix', "\$self" => 'fix', "\$trace" => 'fix' },
                   line             => 29,
                   max_arg_length   => undef,
                   "package"        => "Plack::Middleware::StackTrace",
                   respect_overload => undef,
                   subroutine       => "Plack::Util::__ANON__",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => [],
                   bitmask          => "UUUUUUUUUUUU\25",
                   evaltext         => undef,
                   filename         => "lib/Plack/Middleware/StackTrace.pm",
                   hasargs          => 0,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => undef,
                   line             => 29,
                   max_arg_length   => undef,
                   "package"        => "Plack::Middleware::StackTrace",
                   respect_overload => undef,
                   subroutine       => "(eval)",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => ['fix', 'fix'],
                   bitmask          => "UUUUUUUUUUUU\25",
                   evaltext         => undef,
                   filename         => "lib/Plack/Middleware.pm",
                   hasargs          => 1,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => { "\$self" => \do{my $fix} },
                   line             => 26,
                   max_arg_length   => undef,
                   "package"        => "Plack::Middleware",
                   respect_overload => undef,
                   subroutine       => "Plack::Middleware::StackTrace::call",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => ['fix'],
                   bitmask          => "UUUUUUUUUUUU\25",
                   evaltext         => undef,
                   filename         => "lib/Plack/Middleware/AccessLog.pm",
                   hasargs          => 1,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => {
                                         "\$env"    => \do{my $fix},
                                         "\$self"   => \bless({ app => sub { "???" }, logger => sub { "???" } }, "Plack::Middleware::AccessLog"),
                                         "%formats" => {},
                                       },
                   line             => 21,
                   max_arg_length   => undef,
                   "package"        => "Plack::Middleware::AccessLog",
                   respect_overload => undef,
                   subroutine       => "Plack::Middleware::__ANON__",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => ['fix', 'fix'],
                   bitmask          => "UUUUUUUUUUUU\25",
                   evaltext         => undef,
                   filename         => "lib/Plack/Middleware.pm",
                   hasargs          => 1,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => { "\$self" => \do{my $fix} },
                   line             => 26,
                   max_arg_length   => undef,
                   "package"        => "Plack::Middleware",
                   respect_overload => undef,
                   subroutine       => "Plack::Middleware::AccessLog::call",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => ['fix'],
                   bitmask          => "UUUUUUUUUUUU\25",
                   evaltext         => undef,
                   filename         => "lib/Plack/Middleware/ContentLength.pm",
                   hasargs          => 1,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => {
                                         "\$self" => \bless({ app => sub { "???" } }, "Plack::Middleware::ContentLength"),
                                       },
                   line             => 10,
                   max_arg_length   => undef,
                   "package"        => "Plack::Middleware::ContentLength",
                   respect_overload => undef,
                   subroutine       => "Plack::Middleware::__ANON__",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => ['fix', 'fix'],
                   bitmask          => "UUUUUUUUUUUU\25",
                   evaltext         => undef,
                   filename         => "lib/Plack/Middleware.pm",
                   hasargs          => 1,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => { "\$self" => \do{my $fix} },
                   line             => 26,
                   max_arg_length   => undef,
                   "package"        => "Plack::Middleware",
                   respect_overload => undef,
                   subroutine       => "Plack::Middleware::ContentLength::call",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => ['fix'],
                   bitmask          => "\0\0\0\0\0\0\0\0\0\0\0\0",
                   evaltext         => undef,
                   filename         => "lib/Plack/Util.pm",
                   hasargs          => 1,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => { "\$app" => \sub { "???" }, "\$env" => \do{my $fix} },
                   line             => 107,
                   max_arg_length   => undef,
                   "package"        => "Plack::Util",
                   respect_overload => undef,
                   subroutine       => "Plack::Middleware::__ANON__",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => [],
                   bitmask          => "\0\0\0\0\0\0\0\0\0\0\0\0",
                   evaltext         => undef,
                   filename         => "lib/Plack/Util.pm",
                   hasargs          => 0,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => undef,
                   line             => 107,
                   max_arg_length   => undef,
                   "package"        => "Plack::Util",
                   respect_overload => undef,
                   subroutine       => "(eval)",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => ['fix', 'fix'],
                   bitmask          => "UUUUUUUUUUUU\25",
                   evaltext         => undef,
                   filename         => "lib/Plack/Server/Standalone.pm",
                   hasargs          => 1,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => {
                                         "\$app"           => \do{my $fix},
                                         "\$buf"           => \"",
                                         "\$conn"          => \bless(Symbol::gensym(), "IO::Socket::INET"),
                                         "\$env"           => \do{my $fix},
                                         "\$input"         => \do{my $fix},
                                         "\$is_keepalive"  => \1,
                                         "\$reqlen"        => \145,
                                         "\$res"           => \[400, ["Content-Type", "text/plain"], ["Bad Request"]],
                                         "\$rlen"          => \145,
                                         "\$self"          => \bless({
                                                                host => 0,
                                                                keepalive_timeout => 2,
                                                                listen_sock => bless(Symbol::gensym(), "IO::Socket::INET"),
                                                                max_keepalive_reqs => 100,
                                                                port => 8080,
                                                                timeout => 300,
                                                              }, "Plack::Server::Standalone"),
                                         "\$use_keepalive" => \undef,
                                       },
                   line             => 153,
                   max_arg_length   => undef,
                   "package"        => "Plack::Server::Standalone",
                   respect_overload => undef,
                   subroutine       => "Plack::Util::run_app",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => ['fix', 'fix', 'fix', 'fix', 1, 1],
                   bitmask          => "UUUUUUUUUUUU\25",
                   evaltext         => undef,
                   filename         => "lib/Plack/Server/Standalone.pm",
                   hasargs          => 1,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => {
                                         "\$app" => \do{my $fix},
                                         "\$conn" => \do{my $fix},
                                         "\$env" => \do{my $fix},
                                         "\$max_reqs_per_child" => \undef,
                                         "\$may_keepalive" => \1,
                                         "\$proc_req_count" => \5,
                                         "\$req_count" => \1,
                                         "\$self" => \do{my $fix},
                                       },
                   line             => 111,
                   max_arg_length   => undef,
                   "package"        => "Plack::Server::Standalone",
                   respect_overload => undef,
                   subroutine       => "Plack::Server::Standalone::handle_connection",
                   "wantarray"      => 0,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => ['fix', 'fix'],
                   bitmask          => "UUUUUUUUUUUU\25",
                   evaltext         => undef,
                   filename         => "lib/Plack/Server/Standalone.pm",
                   hasargs          => 1,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => { "\$app" => \do{my $fix}, "\$self" => \do{my $fix} },
                   line             => 62,
                   max_arg_length   => undef,
                   "package"        => "Plack::Server::Standalone",
                   respect_overload => undef,
                   subroutine       => "Plack::Server::Standalone::accept_loop",
                   "wantarray"      => undef,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
                 bless({
                   args             => ['fix', 'fix'],
                   bitmask          => "\0\0\0\0\0\0\0\0\0\0\0\0",
                   evaltext         => undef,
                   filename         => "scripts/plackup",
                   hasargs          => 1,
                   hints            => 2,
                   is_require       => undef,
                   lexicals         => {
                                         "\$app"      => \"eg/dot-psgi/error.psgi",
                                         "\$env"      => \"development",
                                         "\$handler"  => \do{my $fix},
                                         "\$help"     => \0,
                                         "\$server"   => \do{my $fix},
                                         "\@args"     => [],
                                         "\@includes" => [],
                                       },
                   line             => 42,
                   max_arg_length   => undef,
                   "package"        => "main",
                   respect_overload => undef,
                   subroutine       => "Plack::Server::Standalone::run",
                   "wantarray"      => undef,
                 }, "Devel::StackTrace::WithLexicals::Frame"),
               ],
    "index" => 2,
  }, "Devel::StackTrace::WithLexicals");
  ${$a->{frames}[0]{lexicals}{"\$trace"}} = $a;
  $a->{frames}[2]{args}[0] = ${$a->{frames}[0]{lexicals}{"\$env"}};
  $a->{frames}[2]{lexicals}{"\$env"} = $a->{frames}[0]{lexicals}{"\$env"};
  $a->{frames}[2]{lexicals}{"\$self"} = $a->{frames}[0]{lexicals}{"\$self"};
  $a->{frames}[2]{lexicals}{"\$trace"} = $a->{frames}[0]{lexicals}{"\$trace"};
  $a->{frames}[4]{args}[0] = ${$a->{frames}[0]{lexicals}{"\$self"}};
  $a->{frames}[4]{args}[1] = ${$a->{frames}[0]{lexicals}{"\$env"}};
  ${$a->{frames}[4]{lexicals}{"\$self"}} = ${$a->{frames}[0]{lexicals}{"\$self"}};
  $a->{frames}[5]{args}[0] = ${$a->{frames}[0]{lexicals}{"\$env"}};
  ${$a->{frames}[5]{lexicals}{"\$env"}} = ${$a->{frames}[0]{lexicals}{"\$env"}};
  $a->{frames}[6]{args}[0] = ${$a->{frames}[5]{lexicals}{"\$self"}};
  $a->{frames}[6]{args}[1] = ${$a->{frames}[0]{lexicals}{"\$env"}};
  ${$a->{frames}[6]{lexicals}{"\$self"}} = ${$a->{frames}[5]{lexicals}{"\$self"}};
  $a->{frames}[7]{args}[0] = ${$a->{frames}[0]{lexicals}{"\$env"}};
  $a->{frames}[8]{args}[0] = ${$a->{frames}[7]{lexicals}{"\$self"}};
  $a->{frames}[8]{args}[1] = ${$a->{frames}[0]{lexicals}{"\$env"}};
  ${$a->{frames}[8]{lexicals}{"\$self"}} = ${$a->{frames}[7]{lexicals}{"\$self"}};
  $a->{frames}[9]{args}[0] = ${$a->{frames}[0]{lexicals}{"\$env"}};
  ${$a->{frames}[9]{lexicals}{"\$env"}} = ${$a->{frames}[0]{lexicals}{"\$env"}};
  $a->{frames}[11]{args}[0] = ${$a->{frames}[9]{lexicals}{"\$app"}};
  $a->{frames}[11]{args}[1] = ${$a->{frames}[0]{lexicals}{"\$env"}};
  ${$a->{frames}[11]{lexicals}{"\$app"}} = ${$a->{frames}[9]{lexicals}{"\$app"}};
  *{${$a->{frames}[11]{lexicals}{"\$conn"}}} = {
    io_socket_peername => pack("H*","1002c5c57f0000010000000000000000"),
    io_socket_timeout  => undef,
  };
  ${$a->{frames}[11]{lexicals}{"\$env"}} = ${$a->{frames}[0]{lexicals}{"\$env"}};
  ${$a->{frames}[11]{lexicals}{"\$input"}} = *{${$a->{frames}[0]{lexicals}{"\$env"}}->{"psgi.input"}};
  *{${$a->{frames}[11]{lexicals}{"\$self"}}->{listen_sock}} = {
    io_socket_domain  => 2,
    io_socket_proto   => 6,
    io_socket_timeout => undef,
    io_socket_type    => 1,
  };
  $a->{frames}[12]{args}[0] = ${$a->{frames}[11]{lexicals}{"\$self"}};
  $a->{frames}[12]{args}[1] = ${$a->{frames}[0]{lexicals}{"\$env"}};
  $a->{frames}[12]{args}[2] = *{${$a->{frames}[11]{lexicals}{"\$conn"}}};
  $a->{frames}[12]{args}[3] = ${$a->{frames}[9]{lexicals}{"\$app"}};
  ${$a->{frames}[12]{lexicals}{"\$app"}} = ${$a->{frames}[9]{lexicals}{"\$app"}};
  ${$a->{frames}[12]{lexicals}{"\$conn"}} = *{${$a->{frames}[11]{lexicals}{"\$conn"}}};
  ${$a->{frames}[12]{lexicals}{"\$env"}} = ${$a->{frames}[0]{lexicals}{"\$env"}};
  ${$a->{frames}[12]{lexicals}{"\$self"}} = ${$a->{frames}[11]{lexicals}{"\$self"}};
  $a->{frames}[13]{args}[0] = ${$a->{frames}[11]{lexicals}{"\$self"}};
  $a->{frames}[13]{args}[1] = ${$a->{frames}[7]{lexicals}{"\$self"}}->{app};
  ${$a->{frames}[13]{lexicals}{"\$app"}} = ${$a->{frames}[7]{lexicals}{"\$self"}}->{app};
  ${$a->{frames}[13]{lexicals}{"\$self"}} = ${$a->{frames}[11]{lexicals}{"\$self"}};
  $a->{frames}[14]{args}[0] = ${$a->{frames}[11]{lexicals}{"\$self"}};
  $a->{frames}[14]{args}[1] = ${$a->{frames}[7]{lexicals}{"\$self"}}->{app};
  ${$a->{frames}[14]{lexicals}{"\$handler"}} = ${$a->{frames}[7]{lexicals}{"\$self"}}->{app};
  ${$a->{frames}[14]{lexicals}{"\$server"}} = ${$a->{frames}[11]{lexicals}{"\$self"}};
  $a;
};

in (eval) at lib/Plack/Middleware/StackTrace.pm line 29

   26: 
   27:     my $res = do {
   28:         local $@;
   29:         eval { $self->app->($env) };
   30:     };
   31: 
   32:     if (!$res && $trace) {

Show lexical variables

in Plack::Middleware::StackTrace::call at lib/Plack/Middleware.pm line 26

   23: 
   24: sub to_app {
   25:     my $self = shift;
   26:     return sub { $self->call(@_) };
   27: }
   28: 
   29: sub enable {

Show lexical variables

my $self = bless({ app => sub { "???" } }, "Plack::Middleware::StackTrace");

in Plack::Middleware::__ANON__ at lib/Plack/Middleware/AccessLog.pm line 21

   18:     my $self = shift;
   19:     my($env) = @_;
   20: 
   21:     my $res = $self->app->($env);
   22: 
   23:     my $logger = $self->logger || sub { $env->{'psgi.errors'}->print(@_) };
   24:

Show lexical variables

my $env = {
  HTTP_ACCEPT         => "*/*",
  HTTP_HOST           => "localhost:8080",
  HTTP_USER_AGENT     => "curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3",
  PATH_INFO           => "/",
  QUERY_STRING        => "",
  REMOTE_ADDR         => "127.0.0.1",
  REQUEST_METHOD      => "GET",
  REQUEST_URI         => "/",
  SCRIPT_NAME         => "",
  SERVER_NAME         => 0,
  SERVER_PORT         => 8080,
  SERVER_PROTOCOL     => "HTTP/1.1",
  "psgi.errors"       => *main::STDERR,
  "psgi.input"        => \*Plack::Server::Standalone::$input,
  "psgi.multiprocess" => "",
  "psgi.multithread"  => "",
  "psgi.run_once"     => "",
  "psgi.url_scheme"   => "http",
  "psgi.version"      => [1, 0],
};
my $self = bless({ app => sub { "???" }, logger => sub { "???" } }, "Plack::Middleware::AccessLog");
my %formats = ();

in Plack::Middleware::AccessLog::call at lib/Plack/Middleware.pm line 26

   23: 
   24: sub to_app {
   25:     my $self = shift;
   26:     return sub { $self->call(@_) };
   27: }
   28: 
   29: sub enable {

Show lexical variables

my $self = bless({ app => sub { "???" }, logger => sub { "???" } }, "Plack::Middleware::AccessLog");

in Plack::Middleware::__ANON__ at lib/Plack/Middleware/ContentLength.pm line 10

    7: 
    8: sub call {
    9:     my $self = shift;
   10:     my $res  = $self->app->(@_);
   11: 
   12:     my $h = Plack::Util::headers($res->[1]);
   13:     if (!Plack::Util::status_with_no_entity_body($res->[0]) &&

Show lexical variables

my $self = bless({ app => sub { "???" } }, "Plack::Middleware::ContentLength");

in Plack::Middleware::ContentLength::call at lib/Plack/Middleware.pm line 26

   23: 
   24: sub to_app {
   25:     my $self = shift;
   26:     return sub { $self->call(@_) };
   27: }
   28: 
   29: sub enable {

Show lexical variables

my $self = bless({ app => sub { "???" } }, "Plack::Middleware::ContentLength");

in Plack::Middleware::__ANON__ at lib/Plack/Util.pm line 107

  104: sub run_app($$) {
  105:     my($app, $env) = @_;
  106: 
  107:     local $@; my $res = eval { $app->($env) };
  108:     if ($@) {
  109:         my $body = "Internal Server Error";
  110:         $env->{'psgi.errors'}->print($@);

Show lexical variables

my $app = sub { "???" };
my $env = {
  HTTP_ACCEPT         => "*/*",
  HTTP_HOST           => "localhost:8080",
  HTTP_USER_AGENT     => "curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3",
  PATH_INFO           => "/",
  QUERY_STRING        => "",
  REMOTE_ADDR         => "127.0.0.1",
  REQUEST_METHOD      => "GET",
  REQUEST_URI         => "/",
  SCRIPT_NAME         => "",
  SERVER_NAME         => 0,
  SERVER_PORT         => 8080,
  SERVER_PROTOCOL     => "HTTP/1.1",
  "psgi.errors"       => *main::STDERR,
  "psgi.input"        => \*Plack::Server::Standalone::$input,
  "psgi.multiprocess" => "",
  "psgi.multithread"  => "",
  "psgi.run_once"     => "",
  "psgi.url_scheme"   => "http",
  "psgi.version"      => [1, 0],
};

in (eval) at lib/Plack/Util.pm line 107

  104: sub run_app($$) {
  105:     my($app, $env) = @_;
  106: 
  107:     local $@; my $res = eval { $app->($env) };
  108:     if ($@) {
  109:         my $body = "Internal Server Error";
  110:         $env->{'psgi.errors'}->print($@);

Show lexical variables

in Plack::Util::run_app at lib/Plack/Server/Standalone.pm line 153

  150: 
  151:             open my $input, "<", \$buf;
  152:             $env->{'psgi.input'} = $input;
  153:             $res = Plack::Util::run_app $app, $env;
  154:             last;
  155:         }
  156:         if ($reqlen == -2) {

Show lexical variables

my $app = sub { "???" };
my $buf = "";
my $conn = do {
  require Symbol;
  my $a = bless(Symbol::gensym(), "IO::Socket::INET");
  *{$a} = {
    io_socket_peername => pack("H*","1002c5c57f0000010000000000000000"),
    io_socket_timeout  => undef,
  };
  $a;
};
my $env = {
  HTTP_ACCEPT         => "*/*",
  HTTP_HOST           => "localhost:8080",
  HTTP_USER_AGENT     => "curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3",
  PATH_INFO           => "/",
  QUERY_STRING        => "",
  REMOTE_ADDR         => "127.0.0.1",
  REQUEST_METHOD      => "GET",
  REQUEST_URI         => "/",
  SCRIPT_NAME         => "",
  SERVER_NAME         => 0,
  SERVER_PORT         => 8080,
  SERVER_PROTOCOL     => "HTTP/1.1",
  "psgi.errors"       => *main::STDERR,
  "psgi.input"        => \*Plack::Server::Standalone::$input,
  "psgi.multiprocess" => "",
  "psgi.multithread"  => "",
  "psgi.run_once"     => "",
  "psgi.url_scheme"   => "http",
  "psgi.version"      => [1, 0],
};
my $input = \*Plack::Server::Standalone::$input;
my $is_keepalive = 1;
my $reqlen = 145;
my $res = [400, ["Content-Type", "text/plain"], ["Bad Request"]];
my $rlen = 145;
my $self = do {
  require Symbol;
  my $a = bless({
    host => 0,
    keepalive_timeout => 2,
    listen_sock => bless(Symbol::gensym(), "IO::Socket::INET"),
    max_keepalive_reqs => 100,
    port => 8080,
    timeout => 300,
  }, "Plack::Server::Standalone");
  *{$a->{listen_sock}} = {
    io_socket_domain  => 2,
    io_socket_proto   => 6,
    io_socket_timeout => undef,
    io_socket_type    => 1,
  };
  $a;
};
my $use_keepalive = undef;

in Plack::Server::Standalone::handle_connection at lib/Plack/Server/Standalone.pm line 111

  108:                 if ($may_keepalive && $max_reqs_per_child && $proc_req_count >= $max_reqs_per_child) {
  109:                     $may_keepalive = undef;
  110:                 }
  111:                 $self->handle_connection($env, $conn, $app, $may_keepalive, $req_count != 0)
  112:                     or last;
  113:                 # TODO add special cases for clients with broken keep-alive support, as well as disabling keep-alive for HTTP/1.0 proxies
  114:             }

Show lexical variables

my $app = sub { "???" };
my $conn = do {
  require Symbol;
  my $a = bless(Symbol::gensym(), "IO::Socket::INET");
  *{$a} = {
    io_socket_peername => pack("H*","1002c5c57f0000010000000000000000"),
    io_socket_timeout  => undef,
  };
  $a;
};
my $env = {
  HTTP_ACCEPT         => "*/*",
  HTTP_HOST           => "localhost:8080",
  HTTP_USER_AGENT     => "curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3 OpenSSL/0.9.7l zlib/1.2.3",
  PATH_INFO           => "/",
  QUERY_STRING        => "",
  REMOTE_ADDR         => "127.0.0.1",
  REQUEST_METHOD      => "GET",
  REQUEST_URI         => "/",
  SCRIPT_NAME         => "",
  SERVER_NAME         => 0,
  SERVER_PORT         => 8080,
  SERVER_PROTOCOL     => "HTTP/1.1",
  "psgi.errors"       => *main::STDERR,
  "psgi.input"        => \*Plack::Server::Standalone::$input,
  "psgi.multiprocess" => "",
  "psgi.multithread"  => "",
  "psgi.run_once"     => "",
  "psgi.url_scheme"   => "http",
  "psgi.version"      => [1, 0],
};
my $max_reqs_per_child = undef;
my $may_keepalive = 1;
my $proc_req_count = 5;
my $req_count = 1;
my $self = do {
  require Symbol;
  my $a = bless({
    host => 0,
    keepalive_timeout => 2,
    listen_sock => bless(Symbol::gensym(), "IO::Socket::INET"),
    max_keepalive_reqs => 100,
    port => 8080,
    timeout => 300,
  }, "Plack::Server::Standalone");
  *{$a->{listen_sock}} = {
    io_socket_domain  => 2,
    io_socket_proto   => 6,
    io_socket_timeout => undef,
    io_socket_type    => 1,
  };
  $a;
};

in Plack::Server::Standalone::accept_loop at lib/Plack/Server/Standalone.pm line 62

   59: sub run {
   60:     my($self, $app) = @_;
   61:     $self->setup_listener();
   62:     $self->accept_loop($app);
   63: }
   64: 
   65: sub setup_listener {

Show lexical variables

my $app = sub { "???" };
my $self = do {
  require Symbol;
  my $a = bless({
    host => 0,
    keepalive_timeout => 2,
    listen_sock => bless(Symbol::gensym(), "IO::Socket::INET"),
    max_keepalive_reqs => 100,
    port => 8080,
    timeout => 300,
  }, "Plack::Server::Standalone");
  *{$a->{listen_sock}} = {
    io_socket_domain  => 2,
    io_socket_proto   => 6,
    io_socket_timeout => undef,
    io_socket_type    => 1,
  };
  $a;
};

in Plack::Server::Standalone::run at scripts/plackup line 42

   39: 
   40: my @args = map { s/^--//; split /=/, $_ } @ARGV;
   41: my $server = Plack::Loader->auto(@args);
   42: $server->run($handler);
   43: 
   44: __END__
   45:

Show lexical variables

my $app = "eg/dot-psgi/error.psgi";
my $env = "development";
my $handler = sub { "???" };
my $help = 0;
my $server = do {
  require Symbol;
  my $a = bless({
    host => 0,
    keepalive_timeout => 2,
    listen_sock => bless(Symbol::gensym(), "IO::Socket::INET"),
    max_keepalive_reqs => 100,
    port => 8080,
    timeout => 300,
  }, "Plack::Server::Standalone");
  *{$a->{listen_sock}} = {
    io_socket_domain  => 2,
    io_socket_proto   => 6,
    io_socket_timeout => undef,
    io_socket_type    => 1,
  };
  $a;
};
my @args = ();
my @includes = ();