One technique is to use select to redirect STDOUT to a different file handle. It's often convenient to use a file opened on a string:

#!/usr/bin/perl
use warnings;
use strict;

my $log;

open my $logOut, '>', \$log;
my $oldStdOut = select $logOut;

print "this goes to the log string\n";

select $oldStdOut;
close $logOut;

print "From log: $log";
[download]

Prints:

From log: this goes to the log string
[download]

Take a look at perldoc open and search for each instance of 'open STDOUT'. It has example code on how to duplicate and redirect both STDOUT and STDERR.

Grandfather's code will probably work for you, but it's good to know where in the documentation you can look for the random times you need to do this and have forgotten how.

I guess there are some other possibilities here, depending upon whether you are writing to a file or to something that Perl can identify as the console. STDERR is non-buffered while STDOUT is buffered when writing to pipes,files. STDERR will come out right NOW, vs STDOUT which will print when it's buffer is full, maybe 4-8K bytes or so.

#!/usr/bin/perl -w
use strict;
use 5.10.0;  ## needed for "say"

print "First, Order as written:\n";
my $str  = q[new text];
$str .= sample( qw(1 2 3) ); #adds '1' to $str
$str .= q[more new text]; 

print_now( "$str \n" ); 

sub sample {
    print q[sample(): ], @_, "\n"; 
}

sub print_now {
    say @_;   ## or
   # print $FH @_;  # this an error what is $FH?
}

print "Now, reverse order:\n";
####################

my $delayedout;
open (DELAY, '>', \$delayedout) or die "$!";
$str  = q[new text];
$str .= sampleb( qw(1 2 3) ); 
$str .= q[more new text]; 

print_nowb( "$str \n" ); 
print $delayedout; 

sub sampleb {
    print DELAY q[sample(): ], @_, "\n"; 
}

sub print_nowb {
    say @_;       
}
__END__
PRINTS:
First, Order as written:
sample(): 123
new text1more new text # 1 is return value of sample
                       # extra \n comes from say statement.
Now, reverse order:
new text1more new text 

sample(): 123
[download]

UPDATE:

OK, this seems to be the code which did the trick:

  my $Test = Test::Builder->new;
  my @handle_names = qw/ output failure_output todo_output /;
  my %old;
  $old{$_} = $Test->$_ for @handle_names;
  $Test->$_(\*STDOUT) for @handle_names;

  # which was restored like so . . . 
  $Test->todo_output(*STDOUT);
  $Test->failure_output(*STDERR);
  $Test->output(*STDOUT);
[download]

So, listening to what GrandFather, Marshall, and others have said. Here's the refactored code:

use 5.010; 
use strict; 
use warnings; 
my ($fh, $str); 
open ($fh, '>>', \$str) or die "$!";
my $oldSTDOUT = select $fh;

$str .= qq[first line: \n];
say q[can we control the print from a sub? ];
sample( qw(1 2 3 ) );
$str .= sample( qw(4 5 6 ) );
say q[ well... ];

select $oldSTDOUT;
close $fh;

print_now( $str );

sub print_now {
    my $txt = shift;
    $txt =~ s/e/E/g;

    say "txt: $txt";
}

sub sample {
    print 'in sample(): ', @_, "\n";
}

__END__
## output 
txt: first linE:
can wE control thE print from a sub?
in samplE(): 123
in samplE(): 456
1 wEll...        ## the '1' from sample(456)
[download]

Lessons learned:

• open in append mode so we can add to the $str.
• anything going to STDOUT is redirected to the variable
• the legacy subroutine's print is appended to the $str when called inline, but
• the return value of the print is appended to the str when called in concatenation (scalar mode, terminology?)

Problem Solved!