It might be worth copy and pasting key excerpts from your blog here (in readmore tags) in case your link becomes stale.

Thanks toolic! These modules seem to be great and much easier to use, though, they produce really detailed traces (one line for every statement). I would like just one line for each subroutine entered, because the scripts I'm working with are really long. Nevertheless, I will try these modules and see how it works out. :)

Devel::TraceSubs then.

Jenda
Enoch was right!
Enjoy the last years of Rome.

Though Perl is not officially an acronym,there are various backronyms in usage, such as: Practical Extraction and Reporting Language.

If the trace dumps are too long, find a common feature that you are interested in, and filter everything else out.




Dave

Put the following code in a file called: /yourperl/site/Devel/Calls.pm:

package Devel::Calls;

our $lastsub;

sub DB::DB {
    my( $p, $f, $l, $sub ) = caller(1);
    return if $lastsub and $sub eq $lastsub;
    printf STDERR "%s(%u): %s()\n",
        $f//'unknown', $l//'0', $sub//'unknown',
    $lastsub = $sub;
    return;
}

1;
[download]

And then invoke your scripts with perl -d:Calls yoursript.pl

You'll get a trace showing file, line and subroutine name whenever a subroutine is entered, something like:

C:\test>perl -d:Calls nestedSubs.pl 1 2 3
unknown(0): unknown()
nestedSubs.pl(31): main::aaa()
nestedSubs.pl(29): main::bbb()
nestedSubs.pl(28): main::ccc()
nestedSubs.pl(27): main::ddd()
nestedSubs.pl(26): main::eee()
nestedSubs.pl(25): main::fff()
nestedSubs.pl(24): main::ggg()
nestedSubs.pl(23): main::hhh()
nestedSubs.pl(22): main::iii()
nestedSubs.pl(21): main::jjj()
nestedSubs.pl(20): main::kkk()
nestedSubs.pl(19): main::lll()
nestedSubs.pl(18): main::mmm()
nestedSubs.pl(17): main::nnn()
nestedSubs.pl(16): main::ooo()
nestedSubs.pl(15): main::ppp()
nestedSubs.pl(14): main::qqq()
nestedSubs.pl(13): main::rrr()
nestedSubs.pl(12): main::sss()
nestedSubs.pl(11): main::ttt()
nestedSubs.pl(10): main::uuu()
nestedSubs.pl(9): main::vvv()
nestedSubs.pl(8): main::www()
nestedSubs.pl(7): main::xxx()
nestedSubs.pl(6): main::yyy()
nestedSubs.pl(5): main::zzz()
234
[download]

That could obviously be greatly extended, but it may be just what you're looking for.

Here's the blog post as it stands:

Recently I came across a bunch of server side code, implemented in the form of Perl scripts and modules – about a hundred of them. Many of them are a few thousand lines long, and they interact with each other in complex ways.

In order to understand how this system works, I had to figure out the program flow. This was difficult especially because it was not easy to reproduce the input, and I didn’t even know where to start. I decided to take the primitive but effective debugging approach of adding print statements for tracing the flow of execution. Trace statements, as they are formally called, are easier to add in smaller programs though.

In order to automate this process of adding trace statements, I tried 3 ways, one after the other:

1. Parsing with regular expressions: The first and most crude approach was to modify all these scripts, by parsing them, finding subroutine definitions, and adding a print statement right after the beginning of each. However, a lot of cases were overlooked while writing the regular expression, and it ended up matching the word “sub” in strings and comments and the result was disastrous. The code base was ruined beyond hope for manual repair, but of course I had backups on my own machine and also on a repository.
2. PPI: After some research I found a Perl module to parse Perl code. PPI, originally an acronym for Parse::Perl::Isolated, parses Perl code as documents, breaking it down in tokens in a strict hierarchical fashion. More details here. Using this, the task of finding subroutine definitions was simplified and made more reliable. PPI::Document -> find(‘PPI::Statement::Sub’) was all that was needed. Then, finding all the ‘children’ of each sub, and looking for PPI::Structure::Block (by checking their refs) got the beginning of each sub.

   for my $child ( $sub->children ) {
    $child->start->add_content($caller)
    if ref $child eq "PPI::Structure::Block";
   }
   [download]

   $caller is the print statement passed as a string.
3. Hook::LexWrap: If you only want to add a trace statement (or any piece of code) at the beginning / end of a subroutine, Hook::LexWrap is a much cleaner way to do this. It doesn’t need you to change the original subroutines in any way. Just adding a few lines of code at the start of each file will suffice. In the following code, @all_subs is the array containing the names of all subroutines in the current file. The “wrap $sub, pre =>”line pre-wraps a subroutine, i.e. executes a piece of code just before the subroutine is executed.

   my @all_subs = qw (sub1 sub2);
   for my $sub (@all_subs) {
    wrap $sub, pre => sub {
    print "Calling '$sub' in file: $0\n";
    };
   }
   [download]

Unless you have permission from the author or there is a posted license/copyright to allow it, wholesale reposts aren't kosher. :|