See Devel::TraceFuncs for one way to do this.

It wouldn't be too hard to write a module, say Devel::TraceMethods that would be used like:

use Module::Name;
use Devel::TraceMethods qw( Module::Name );
[download]

You could even make this work in the face of a module that used AUTOLOAD (by having your AUTOLOAD log and then, if needed, call their AUTOLOAD, but then shuffle the new routine into the other namespace when that returns).

Unfortunately, I'm not free to write one at the moment.

Update: The above would break can for this module, so the start-up and AUTOLOAD should build shim routines that log and then call the real routine.

That's a good idea. :) I handled it slightly differently (mm, closures), but it has the effect I think you intended.

Edit by tye to link to An Implementation of Devel::TraceMethods not Zombie grandma ;)

That's clever. I suppose a quick and dirty way would be to define ChildModule of Module and only define an ChildModule::Autoload. ChildModule::Autoload would log the function call, then call SUPER::ModuleSub

Sorry, no. SUPER:: requires @ChildModule::ISA contain your Module, which also means that AUTOLOAD won't be called for methods that are defined in your Module.

But you can do something like:

package AutoTrace;
my %pkgMap;
sub AUTOLOAD {
    logCall( $AUTOLOAD, @_ );
    my $wantPkg= $AUTOLOAD =~ s/(.*):://;
    $AUTOLOAD= $pkgMap{$wantPkg}."::".$AUTOLOAD;
    goto &$AUTOLOAD;
}
$pkgMap{ChildModule}= "Module";
*ChildModule::AUTOLOAD= \&AUTOLOAD;
[download]

instead of the SUPER:: trick (again, can won't work, which often won't be a problem).
        - tye (but my friends call me "Tye")

If you set the frame option in the debugger, it'll tell you when you enter a subroutine:
PERLDB_OPTS="frame=1" perl -d myprogram.pl
If you just want a trace (and don't need to debug interactively), you can use the NonStop option:
 PERLDB_OPTS="NonStop frame=1" perl -d myprogram

The output with NonStop on (with interspersed program output) looks like this:

Package pathdiff.pl.
entering Algorithm::Diff::traverse_sequences
 entering Algorithm::Diff::_longestCommonSubsequence
  entering CODE(0x80fdd48)
  entering CODE(0x80fdd48)
  entering CODE(0x80fdd48)
  entering Algorithm::Diff::_withPositionsOfInInterval
   entering CODE(0x80fdcb8)
  entering CODE(0x80fdcb8)
 entering main::match
same:   a       a
 entering main::discA
omitA:  b
 entering main::discB
omitB:          c
[download]

Updated: added output sample

Forgive my ignorance, but wouldn't using this module require me to change the code in ALL my subroutines? This is what I was trying to avoid. I could be misunderstanding the documentation, however.