Profile of DBIx/Class/Storage/BlockRunner.pm

Filename	/usr/share/perl5/DBIx/Class/Storage/BlockRunner.pm
Statements	Executed 2125 statements in 7.19ms

Subroutines
Calls	P	F	Exclusive Time	Inclusive Time	Subroutine
1	1	1	7.89ms	10.7ms	DBIx::Class::Storage::BlockRunner::BEGIN@16
318	1	1	6.14ms	276ms	DBIx::Class::Storage::BlockRunner::run
318	1	1	6.11ms	265ms	DBIx::Class::Storage::BlockRunner::_run
318	2	1	3.54ms	241ms	DBIx::Class::Storage::BlockRunner::__ANON__[:155]
318	2	1	2.94ms	5.23ms	DBIx::Class::Storage::BlockRunner::__ANON__[:233]
1	1	1	751µs	1.03ms	DBIx::Class::Storage::BlockRunner::BEGIN@9
1	1	1	18µs	22µs	DBIx::Class::Storage::BlockRunner::BEGIN@4
1	1	1	13µs	241µs	DBIx::Class::Storage::BlockRunner::BEGIN@34
1	1	1	12µs	33µs	DBIx::Class::Storage::BlockRunner::BEGIN@10
1	1	1	11µs	32µs	DBIx::Class::Storage::BlockRunner::BEGIN@12
1	1	1	11µs	35µs	DBIx::Class::Storage::BlockRunner::BEGIN@11
1	1	1	9µs	52µs	DBIx::Class::Storage::BlockRunner::__ANON__[:29]
1	1	1	7µs	13µs	DBIx::Class::Storage::BlockRunner::BEGIN@5
1	1	1	7µs	39µs	DBIx::Class::Storage::BlockRunner::BEGIN@8
1	1	1	6µs	6µs	DBIx::Class::Storage::BlockRunner::BEGIN@7
1	1	1	2µs	2µs	DBIx::Class::Storage::BlockRunner::max_attempts (xsub)
2	2	1	1µs	1µs	DBIx::Class::Storage::BlockRunner::storage (xsub)
1	1	1	600ns	600ns	DBIx::Class::Storage::BlockRunner::wrap_txn (xsub)
0	0	0	0s	0s	DBIx::Class::Storage::BlockRunner::__ANON__[:151]
0	0	0	0s	0s	DBIx::Class::Storage::BlockRunner::__ANON__[:154]
0	0	0	0s	0s	DBIx::Class::Storage::BlockRunner::catch {...}
0	0	0	0s	0s	DBIx::Class::Storage::BlockRunner::last_exception
0	0	0	0s	0s	DBIx::Class::Storage::BlockRunner::throw_exception
0	0	0	0s	0s	DBIx::Class::Storage::BlockRunner::try {...}

Call graph for these subroutines as a Graphviz dot language file.

Line	State ments	Time on line	Calls	Time in subs	Code
1					package # hide from pause until we figure it all out
2					DBIx::Class::Storage::BlockRunner;
3
4			2	26µs	# spent 22µs (18+4) within DBIx::Class::Storage::BlockRunner::BEGIN@4 which was called: # once (18µs+4µs) by DBIx::Class::Storage::BEGIN@16 at line 4 use warnings; # spent 22µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@4 # spent 4µs making 1 call to warnings::import
5			2	19µs	# spent 13µs (7+6) within DBIx::Class::Storage::BlockRunner::BEGIN@5 which was called: # once (7µs+6µs) by DBIx::Class::Storage::BEGIN@16 at line 5 use strict; # spent 13µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@5 # spent 6µs making 1 call to strict::import
6
7			1	6µs	# spent 6µs within DBIx::Class::Storage::BlockRunner::BEGIN@7 which was called: # once (6µs+0s) by DBIx::Class::Storage::BEGIN@16 at line 7 use DBIx::Class::Exception; # spent 6µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@7
8			2	72µs	# spent 39µs (7+33) within DBIx::Class::Storage::BlockRunner::BEGIN@8 which was called: # once (7µs+33µs) by DBIx::Class::Storage::BEGIN@16 at line 8 use DBIx::Class::Carp; # spent 39µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@8 # spent 33µs making 1 call to DBIx::Class::Carp::import
9			2	1.05ms	# spent 1.03ms (751µs+280µs) within DBIx::Class::Storage::BlockRunner::BEGIN@9 which was called: # once (751µs+280µs) by DBIx::Class::Storage::BEGIN@16 at line 9 use Context::Preserve 'preserve_context'; # spent 1.03ms making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@9 # spent 24µs making 1 call to Exporter::import
10			2	54µs	# spent 33µs (12+21) within DBIx::Class::Storage::BlockRunner::BEGIN@10 which was called: # once (12µs+21µs) by DBIx::Class::Storage::BEGIN@16 at line 10 use DBIx::Class::_Util qw(is_exception qsub); # spent 33µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@10 # spent 21µs making 1 call to Exporter::import
11			2	60µs	# spent 35µs (11+25) within DBIx::Class::Storage::BlockRunner::BEGIN@11 which was called: # once (11µs+25µs) by DBIx::Class::Storage::BEGIN@16 at line 11 use Scalar::Util qw(weaken blessed reftype); # spent 35µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@11 # spent 25µs making 1 call to Exporter::import
12			2	54µs	# spent 32µs (11+21) within DBIx::Class::Storage::BlockRunner::BEGIN@12 which was called: # once (11µs+21µs) by DBIx::Class::Storage::BEGIN@16 at line 12 use Try::Tiny; # spent 32µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@12 # spent 21µs making 1 call to Exporter::import
13
14					# DO NOT edit away without talking to riba first, he will just put it back
15					# BEGIN pre-Moo2 import block
16					# spent 10.7ms (7.89+2.77) within DBIx::Class::Storage::BlockRunner::BEGIN@16 which was called: # once (7.89ms+2.77ms) by DBIx::Class::Storage::BEGIN@16 at line 31 BEGIN {
17					my $initial_fatal_bits = (${^WARNING_BITS}\|\|'') & $warnings::DeadBits{all};
18
19					local $ENV{PERL_STRICTURES_EXTRA} = 0;
20					# load all of these now, so that lazy-loading does not escape
21					# the current PERL_STRICTURES_EXTRA setting
22					require Sub::Quote;
23					require Sub::Defer;
24					require Moo;
25					require Moo::Object;
26					require Method::Generate::Accessor;
27					require Method::Generate::Constructor;
28
29			3	398µs	# spent 52µs (9+43) within DBIx::Class::Storage::BlockRunner::__ANON__[/usr/share/perl5/DBIx/Class/Storage/BlockRunner.pm:29] which was called: # once (9µs+43µs) by import::into at line 36 of Import/Into.pm Moo->import; # spent 355µs making 1 call to Moo::import # spent 28µs making 1 call to strictures::import # spent 15µs making 1 call to Module::Runtime::use_module
30					${^WARNING_BITS} &= ( $initial_fatal_bits \| ~ $warnings::DeadBits{all} );
31			1	10.7ms	} # spent 10.7ms making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@16
32					# END pre-Moo2 import block
33
34			2	470µs	# spent 241µs (13+228) within DBIx::Class::Storage::BlockRunner::BEGIN@34 which was called: # once (13µs+228µs) by DBIx::Class::Storage::BEGIN@16 at line 34 use namespace::clean; # spent 241µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@34 # spent 228µs making 1 call to namespace::clean::import
35
36					=head1 NAME
37
38					DBIx::Class::Storage::BlockRunner - Try running a block of code until success with a configurable retry logic
39
40					=head1 DESCRIPTION
41
42					=head1 METHODS
43
44					=cut
45
46			1	1.58ms	has storage => ( # spent 1.58ms making 1 call to Moo::has
47					is => 'ro',
48					required => 1,
49					);
50
51			1	105µs	has wrap_txn => ( # spent 105µs making 1 call to Moo::has
52					is => 'ro',
53					required => 1,
54					);
55
56					# true - retry, false - rethrow, or you can throw your own (not catching)
57			2	3.78ms	has retry_handler => ( # spent 3.78ms making 1 call to Moo::has # spent 3µs making 1 call to DBIx::Class::_Util::qsub
58					is => 'ro',
59					required => 1,
60					isa => qsub q{
61					(Scalar::Util::reftype($_[0])\|\|'') eq 'CODE'
62					or DBIx::Class::Exception->throw('retry_handler must be a CODE reference')
63					},
64					);
65
66			2	332µs	has retry_debug => ( # spent 329µs making 1 call to Moo::has # spent 2µs making 1 call to DBIx::Class::_Util::qsub
67					is => 'rw',
68					# use a sub - to be evaluated on the spot lazily
69					default => qsub '$ENV{DBIC_STORAGE_RETRY_DEBUG}',
70					lazy => 1,
71					);
72
73			1	123µs	has max_attempts => ( # spent 123µs making 1 call to Moo::has
74					is => 'ro',
75					default => 20,
76					);
77
78			2	322µs	has failed_attempt_count => ( # spent 312µs making 1 call to Moo::has # spent 9µs making 1 call to DBIx::Class::_Util::qsub
79					is => 'ro',
80					init_arg => undef, # ensures one can't pass the value in
81					writer => '_set_failed_attempt_count',
82					default => 0,
83					lazy => 1,
84					trigger => qsub q{
85					$_[0]->throw_exception( sprintf (
86					'Reached max_attempts amount of %d, latest exception: %s',
87					$_[0]->max_attempts, $_[0]->last_exception
88					)) if $_[0]->max_attempts <= ($_[1]\|\|0);
89					},
90					);
91
92			2	394µs	has exception_stack => ( # spent 392µs making 1 call to Moo::has # spent 1µs making 1 call to DBIx::Class::_Util::qsub
93					is => 'ro',
94					init_arg => undef,
95					clearer => '_reset_exception_stack',
96					default => qsub q{ [] },
97					lazy => 1,
98					);
99
100					sub last_exception { shift->exception_stack->[-1] }
101
102					sub throw_exception { shift->storage->throw_exception (@_) }
103
104					# spent 276ms (6.14+269) within DBIx::Class::Storage::BlockRunner::run which was called 318 times, avg 866µs/call: # 318 times (6.14ms+269ms) by DBIx::Class::Storage::DBI::dbh_do at line 855 of DBIx/Class/Storage/DBI.pm, avg 866µs/call sub run {
105	85	34µs			my $self = shift;
106
107	85	219µs	318	1.11ms	$self->_reset_exception_stack; # spent 1.11ms making 318 calls to DBIx::Class::Storage::BlockRunner::_reset_exception_stack, avg 3µs/call
108	85	167µs	318	3.00ms	$self->_set_failed_attempt_count(0); # spent 3.00ms making 318 calls to DBIx::Class::Storage::BlockRunner::_set_failed_attempt_count, avg 9µs/call
109
110	85	38µs			my $cref = shift;
111
112	85	310µs	318	341µs	$self->throw_exception('run() requires a coderef to execute as its first argument') # spent 341µs making 318 calls to Scalar::Util::reftype, avg 1µs/call
113					if ( reftype($cref)\|\|'' ) ne 'CODE';
114
115	85	101µs	1	900ns	my $storage = $self->storage; # spent 900ns making 1 call to DBIx::Class::Storage::BlockRunner::storage
116
117	85	52µs			return $cref->( @_ ) if (
118					$storage->{_in_do_block}
119					and
120					! $self->wrap_txn
121					);
122
123	85	99µs			local $storage->{_in_do_block} = 1 unless $storage->{_in_do_block};
124
125	85	372µs	318	265ms	return $self->_run($cref, @_); # spent 265ms making 318 calls to DBIx::Class::Storage::BlockRunner::_run, avg 833µs/call
126					}
127
128					# this is the actual recursing worker
129					# spent 265ms (6.11+259) within DBIx::Class::Storage::BlockRunner::_run which was called 318 times, avg 833µs/call: # 318 times (6.11ms+259ms) by DBIx::Class::Storage::BlockRunner::run at line 125, avg 833µs/call sub _run {
130					# internal method - we know that both refs are strong-held by the
131					# calling scope of run(), hence safe to weaken everything
132	85	396µs	318	516µs	weaken( my $self = shift ); # spent 516µs making 318 calls to Scalar::Util::weaken, avg 2µs/call
133	85	236µs	318	271µs	weaken( my $cref = shift ); # spent 271µs making 318 calls to Scalar::Util::weaken, avg 852ns/call
134
135	85	76µs			my $args = @_ ? \@_ : [];
136
137					# from this point on (defined $txn_init_depth) is an indicator for wrap_txn
138					# save a bit on method calls
139	85	97µs	1	600ns	my $txn_init_depth = $self->wrap_txn ? $self->storage->transaction_depth : undef; # spent 600ns making 1 call to DBIx::Class::Storage::BlockRunner::wrap_txn
140	85	14µs			my $txn_begin_ok;
141
142	85	32µs			my $run_err = '';
143
144					# spent 241ms (3.54+237) within DBIx::Class::Storage::BlockRunner::__ANON__[/usr/share/perl5/DBIx/Class/Storage/BlockRunner.pm:155] which was called 318 times, avg 757µs/call: # 317 times (3.53ms+237ms) by Context::Preserve::preserve_context at line 32 of Context/Preserve.pm, avg 758µs/call # once (12µs+421µs) by Context::Preserve::preserve_context at line 22 of Context/Preserve.pm return preserve_context {
145					try {
146	85	32µs			if (defined $txn_init_depth) {
147					$self->storage->txn_begin;
148					$txn_begin_ok = 1;
149					}
150	85	135µs	318	224ms	$cref->( @$args ); # spent 224ms making 318 calls to DBIx::Class::Storage::DBI::__ANON__[DBIx/Class/Storage/DBI.pm:855], avg 705µs/call
151					} catch {
152					$run_err = $_;
153					(); # important, affects @_ below
154	85	3.05ms	636	237ms	}; # spent 235ms making 318 calls to Try::Tiny::try, avg 738µs/call # spent 2.48ms making 318 calls to Try::Tiny::catch, avg 8µs/call
155					# spent 5.23ms (2.94+2.29) within DBIx::Class::Storage::BlockRunner::__ANON__[/usr/share/perl5/DBIx/Class/Storage/BlockRunner.pm:233] which was called 318 times, avg 16µs/call: # 317 times (2.92ms+2.29ms) by Context::Preserve::preserve_context at line 37 of Context/Preserve.pm, avg 16µs/call # once (16µs+8µs) by Context::Preserve::preserve_context at line 27 of Context/Preserve.pm } replace => sub {
156	85	57µs			my @res = @_;
157
158	85	98µs	1	500ns	my $storage = $self->storage; # spent 500ns making 1 call to DBIx::Class::Storage::BlockRunner::storage
159	85	73µs	1	800ns	my $cur_depth = $storage->transaction_depth; # spent 800ns making 1 call to DBIx::Class::Storage::DBI::mysql::transaction_depth
160
161	85	31µs			if (defined $txn_init_depth and ! is_exception $run_err) {
162					my $delta_txn = (1 + $txn_init_depth) - $cur_depth;
163
164					if ($delta_txn) {
165					# a rollback in a top-level txn_do is valid-ish (seen in the wild and our own tests)
166					carp (sprintf
167					'Unexpected reduction of transaction depth by %d after execution of '
168					. '%s, skipping txn_commit()',
169					$delta_txn,
170					$cref,
171					) unless $delta_txn == 1 and $cur_depth == 0;
172					}
173					else {
174					$run_err = eval { $storage->txn_commit; 1 } ? '' : $@;
175					}
176					}
177
178					# something above threw an error (could be the begin, the code or the commit)
179	85	262µs	318	2.29ms	if ( is_exception $run_err ) { # spent 2.29ms making 318 calls to DBIx::Class::_Util::is_exception, avg 7µs/call
180
181					# attempt a rollback if we did begin in the first place
182					if ($txn_begin_ok) {
183					# some DBDs go crazy if there is nothing to roll back on, perform a soft-check
184					my $rollback_exception = $storage->_seems_connected
185					? (! eval { $storage->txn_rollback; 1 }) ? $@ : ''
186					: 'lost connection to storage'
187					;
188
189					if ( $rollback_exception and (
190					! defined blessed $rollback_exception
191					or
192					! $rollback_exception->isa('DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION')
193					) ) {
194					$run_err = "Transaction aborted: $run_err. Rollback failed: $rollback_exception";
195					}
196					}
197
198					push @{ $self->exception_stack }, $run_err;
199
200					# this will throw if max_attempts is reached
201					$self->_set_failed_attempt_count($self->failed_attempt_count + 1);
202
203					# init depth of > 0 ( > 1 with AC) implies nesting - no retry attempt queries
204					$storage->throw_exception($run_err) if (
205					(
206					defined $txn_init_depth
207					and
208					$txn_init_depth > ( $storage->{_dbh_autocommit} ? 0 : 1 )
209
210
211					) or ! $self->retry_handler->($self)
212					);
213
214					# we got that far - let's retry
215					carp( sprintf 'Retrying %s (attempt %d) after caught exception: %s',
216					$cref,
217					$self->failed_attempt_count + 1,
218					$run_err,
219					) if $self->retry_debug;
220
221					$storage->ensure_connected;
222					# if txn_depth is > 1 this means something was done to the
223					# original $dbh, otherwise we would not get past the preceding if()
224					$storage->throw_exception(sprintf
225					'Unexpected transaction depth of %d on freshly connected handle',
226					$storage->transaction_depth,
227					) if (defined $txn_init_depth and $storage->transaction_depth);
228
229					return $self->_run($cref, @$args);
230					}
231
232	85	268µs			return wantarray ? @res : $res[0];
233	85	929µs	318	258ms	}; # spent 258ms making 318 calls to Context::Preserve::preserve_context, avg 811µs/call
234					}
235
236					=head1 FURTHER QUESTIONS?
237
238					Check the list of L<additional DBIC resources\|DBIx::Class/GETTING HELP/SUPPORT>.
239
240					=head1 COPYRIGHT AND LICENSE
241
242					This module is free software L<copyright\|DBIx::Class/COPYRIGHT AND LICENSE>
243					by the L<DBIx::Class (DBIC) authors\|DBIx::Class/AUTHORS>. You can
244					redistribute it and/or modify it under the same terms as the
245					L<DBIx::Class library\|DBIx::Class/COPYRIGHT AND LICENSE>.
246
247					=cut
248
249			1	397µs	1; # spent 397µs making 1 call to B::Hooks::EndOfScope::XS::__ANON__

					# spent 2µs within DBIx::Class::Storage::BlockRunner::max_attempts which was called: # once (2µs+0s) by DBIx::Class::Storage::BlockRunner::_set_failed_attempt_count at line 29 of (eval 1111)[Sub/Quote.pm:5] sub DBIx::Class::Storage::BlockRunner::max_attempts; # xsub
					# spent 1µs within DBIx::Class::Storage::BlockRunner::storage which was called 2 times, avg 700ns/call: # once (900ns+0s) by DBIx::Class::Storage::BlockRunner::run at line 115 # once (500ns+0s) by DBIx::Class::Storage::BlockRunner::__ANON__[/usr/share/perl5/DBIx/Class/Storage/BlockRunner.pm:233] at line 158 sub DBIx::Class::Storage::BlockRunner::storage; # xsub
					# spent 600ns within DBIx::Class::Storage::BlockRunner::wrap_txn which was called: # once (600ns+0s) by DBIx::Class::Storage::BlockRunner::_run at line 139 sub DBIx::Class::Storage::BlockRunner::wrap_txn; # xsub