How do I get Cluck output into a log file?

tphyahoo has asked for the wisdom of the Perl Monks concerning the following question:

O wise ones,

I have a very simple debugging methodology for now, I just rolled my own logMessage function and stuck it in a module. logMessage outputs the message to the dos window ongoingly (winxp/ASPN) and also writes it to a log file. I messed around with the perl debugger, but I just wound up liking this way better.

This was working fine, until I started using Carp.

Problem is if, from inside a module, I do something like

    wipeLog();
    logMessage("testing");
    logMessage( Carp::cluck("Cluck at "));
[download]

I wind up with

testing
1
[download]

in my log.txt file. The messages get output to stdout, but I guess cluck is returning 1 instead of the debugging message to my logMessage() function. How do I get the actual message out of cluck so I can pass it to another function?

Here is the complete code for testcarp.pl, testcarp.pm, logger.pm, which all sit together in their own directory and work fine, other than the output to log.txt.

#testcarp.pl
# custom module
use TestCarp('test_carp');
test_carp();
[download]

#testcarp.pm

package TestCarp;
use strict;
use Logger('logMessage','wipeLog');

use base 'Exporter';
our @EXPORT_OK = ('test_carp');

sub test_carp {
    wipeLog();
    logMessage("testing");
    logMessage( Carp::cluck("Cluck at "));

}

1;
[download]

#logger.pm
use strict;
package Logger;

use base 'Exporter';
our @EXPORT_OK = ('logMessage','wipeLog');

sub logMessage {
    my $message = shift;
    print $message; # maybe could turn this on and off with command li
+ne option.  do later?

    my $logFileName = "log.txt";
    open F, ">> $logFileName" or die "Cannot open log file: $logFileNa
+me";
    print F $message,"\n";
    close F;    
}

sub wipeLog {
    my $logFileName = "log.txt";
    open F, "> $logFileName" or die "Cannot open log file: $logFileNam
+e";
    close F;
}

1;
[download]

I know there are other frameworks for dealing with logging and debugging, and if anybody would care to comment on how I could be doing this better, fire away.

Thank you, o monks!

thomas.

Comment on How do I get Cluck output into a log file? Select or Download Code

Replies are listed 'Best First'.
Re: How do I get Cluck output into a log file? by steves (Curate) on Dec 29, 2004 at 13:57 UTC
The messages get output to stdout, but I guess cluck is returning 1 instead of the debugging message to my logMessage() function. That is correct. cluck() doesn't return a message, it prints one, so the way you're trying to use it will not work. Carp has shortmess and longmess methods that return the message strings instead of outputting them. Those will work for what you're trying to do.	[reply]
But cluck gives you more. by tphyahoo (Vicar) on Dec 29, 2004 at 14:23 UTC
Steves, thanks for pointing that out, but I'm still not quite where I want with this. Shortmess and longmess output stuff write stuff along the lines of `shortmess at at testcarp.pl line 4 longmess at at testcarp.pl line 4` [download] However, they do not mention what line of testcarp.PM, the module, the debugging message occurs at. Whereas cluck does give you this. Is there some way I can get this additional info, grabbing it out of cluck, or otherwise? thanks! thomas.	[reply] [d/l]
Re: But cluck gives you more. by steves (Curate) on Dec 29, 2004 at 16:03 UTC
longmess and shortmess do include caller information. The key is how deep you are in the stack, as Carp has a set of rules for deciding how much stack trace (if any) to include. I'm not 100% sure the rules are consistent across all the calls. Here's a test program that illustrates. Maybe a monk with more Carp knowledge can comment. I need to think about it some more ... I suspect there's some nonobvious consistency here. `use strict; use Carp qw(cluck); sub test_errors { cluck "First test message"; my $long = Carp::longmess("Second test message"); my $short = Carp::longmess("Third test message"); print STDERR $long; print STDERR $short; test2(); } sub test2 { cluck "Fourth test message"; my $long = Carp::longmess("Fifth test message"); my $short = Carp::longmess("Sixth test message"); print STDERR $long; print STDERR $short; } test_errors();` [download] produces: `First test message at cluckt line 8 main::test_errors() called at cluckt line 30 Second test message at cluckt line 30 Third test message at cluckt line 30 Fourth test message at cluckt line 21 main::test2() called at cluckt line 16 main::test_errors() called at cluckt line 30 Fifth test message at cluckt line 16 main::test_errors() called at cluckt line 30 Sixth test message at cluckt line 16 main::test_errors() called at cluckt line 30` [download] Basically, longmess and shortmess appear to always include one less stack frame than cluck does. Maybe someone should cluck about this. ;-) Note that I got the same results by calling longmess and shortmess directly in the print calls rather than getting the messages into local variables first.	[reply] [d/l] [select]
Re: But cluck gives you more. by osunderdog (Deacon) on Dec 29, 2004 at 15:27 UTC
If I understand your question, I think you are looking for information available in `caller`. You don't want to know who called you, but who called something that called you. `use strict; use Carp; trace('foo'); trace('bar'); func(); sub func { trace('in func'); } sub trace { my $string = shift; my ($package, $filename, $line, $subroutine, $hasargs, $wantarray, $evaltext, $is_require, $hints, $bitmask) = caller( +1); if($subroutine) { print "[$subroutine]: $string\n"; } else { print "[IN MAIN]: $string\n"; } } __END__ [IN MAIN]: foo [IN MAIN]: bar [main::func]: in func` [download] *"Look, Shiny Things!"* is not a better business strategy than compatibility and reuse. OSUnderdog	[reply] [d/l] [select]