Controlling order of object destruction - perl

Question

My web application uses a Log module to record various events. The log object is initialized by being passed a CGI::Session object containing various information about the user. This information gets copied to the log object's data fields. Owing to the volume of activity on the site and the fact that a single visit to the site can result in multiple loggable events, the log module currently caches all events in memory, then actually writes them to the log file in the DESTROY function. However, this results in the session parameters being frozen at the time the log object is initialized, which occurs at the beginning of the request.
Recently, some new parameters were required to be logged that a) would be stored in the session object, and b) needed to be logged as their final, instead of initial value (and would potentially change during execution). My initial idea was to instead store a reference to the session object in the log object, but as the DESTROY function typically is called in global destruction, I have no guarantee that the session object will still be defined when the log is destroyed. Is there a way to guarantee that the CGI::Session object won't be destroyed before my log, hopefully without having to add an explicit destruct to each page of the app?
#old
package Log;
sub new
{
my $class = shift;
my $session = shift; #CGI::Session
my $self = {session => {customer_id => $session->param('customer_id')}, events => []};
return bless $self, $class;
}
sub log_event
{
my $self = shift;
my $event = shift;
push #{$self->{'events'}}, {event_type => $event->{'type'}, timestamp => $event->{'timestamp'}};
}
sub DESTROY
{
my $self = shift;
if (scalar #{$self->{'events'}})
{
open LOG, "/tmp/log";
print LOG, Dumper({session => $self->{'session'}, events => $self->{'events'}});
close LOG;
}
}
#new
package Log;
sub new
{
my $class = shift;
my $session = shift;#CGI::Session
my $self = {session => $session, events => []};
return bless $self, $class;
}
sub log_event
{
my $self = shift;
my $event = shift;
push #{$self->{'events'}}, {event_type => $event->{'type'}, timestamp => $event->{'timestamp'}};
}
sub DESTROY
{
my $self = shift;
if (scalar #{$self->{'events'}})
{
open LOG, "/tmp/log";
print LOG, Dumper({session => {customer_id => $self->{'session'}->param('customer_id')}}, events => $self->{'events'}});
close LOG;
}
}

Answer 1

Perl uses reference-counting to govern object destruction[1]. This means that under normal circumstances, if object A references object B, object A will be destroyed before object B.
This fails if the object survives until global destruction. There are two circumstances where this happens:
Reference cycle. If two objects directly or indirectly reference each other, the order of destruction of the objects involved in the cycles is unpredictable.
Global variable. The order in which objects referenced by package variables (and therefore objects directly or indirectly referenced by them) is unpredictable (though Perl does try to do the right thing).
So if the log holds a reference to a session object (as it appears you are doing), the log will be destroyed first (within the limits I mentioned above).
If the objects are in package variables instead of lexical (my) variables, and if you don't want to change that, you could use the following in the main program:
use Sub::ScopeFinalizer qw( scope_finalizer );
# Here or wherever.
our $log;
our $session;
{
# The lexicals within these curlies will get destroyed before
# global destruction. This will lead to the code ref provided to
# scope_finalizer getting called before global destruction.
my $guard = scope_finalizer {
# The order doesn't matter because the log object
# holds a reference to the session object.
$log = undef;
$session = undef;
};
# ... Main program here ...
}
As long as the log holds a reference to the session, this will ensure that the objects are destroyed in the correct order. Even if the program dies or exits.
You can tell if objects of a class are surviving until global destruction by adding the following code to the program and examining the order of the output:
DESTROY { warn($_[0]->id . " destroyed.\n"); } # In the class
END { warn("Global destruction."); }
In this post, I'm using the word "object" loosely. I don't just means instances of classes, but also scalars, arrays, hashes subs and other values and variables.
Similarly, referencing refers not just to a Perl reference, but other forms of referencing. For example, arrays and hashes reference their elements, and subs reference variables they capture, etc.