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

# Error trace

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

1. 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 = ();