If this could be done in a 'better' way, I'd enjoy hearing it. Criticisms welcome.

Recently needed to basically cache the output of almost every class method in one of my modules that is part of a web app. Every method runs a different database query and encodes the results to JSON. The results change daily, so upstream of the module implementation there is logic that enforces a 12 hour TTL for anything any method returns. In the interim time though, there's no reason for the app to run these database queries at all when it already did the work. Reading about possible approaches to the problem on stack overflow yesterday I saw that use of autoload was discouraged, so this is what I came up with and as far as I can tell, after running two days in DEV, it appears to have no issues. I'm actually quite pleased, because this approach allowed me to be 'clever' without an implementation that is unmaintainable and unintelligible by others... Gist here

use strict;
use warnings;

package My::Class::Proxy; # Drop-in replacement for 'Some Class'

# Proxies all public method calls to Some::Class in order to provide s
+mart
# caching and memoization, e.g.- avoiding expensive DB queries when no
+t required

use 5.020;
use Moose;

extends 'Some::Class';

use Moose::Util qw();

my $meta = Moose::Util::find_meta( 'Some::Class' );

my @nocache = qw( new meta DESTROY AUTOLOAD );

state $outputs = {};

for my $method ( $meta->get_method_list )
{
   # don't memo-ize blaclisted or private methods
   next if ( grep { $_ eq $method } @nocache or $method =~ /^_/ );

   around $method => sub
   {
      my ( $orig, $self, $refresh, @args ) = @_;

      $outputs = {} if !!$refresh;

      @args = map { $_ // '' } @args;

      my $call_key = join '', $orig, @args;

      return $outputs->{ $call_key } if defined $outputs->{ $call_key 
+};

      $outputs->{ $call_key } = $self->$orig( @args );

      return $outputs->{ $call_key };
   };
}

# Moose-specific optimization
__PACKAGE__->meta->make_immutable();

1;
[download]