Profile of DBIx/Class/Storage/BlockRunner.pm

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

Subroutines
Calls	P	F	Exclusive Time	Inclusive Time	Subroutine
1	1	1	8.67ms	11.0ms	DBIx::Class::Storage::BlockRunner::BEGIN@16
89	1	1	1.62ms	34.9ms	DBIx::Class::Storage::BlockRunner::run
89	1	1	1.54ms	31.3ms	DBIx::Class::Storage::BlockRunner::_run
89	2	1	789µs	20.9ms	DBIx::Class::Storage::BlockRunner::__ANON__[:155]
89	2	1	716µs	1.29ms	DBIx::Class::Storage::BlockRunner::__ANON__[:233]
1	1	1	171µs	216µs	DBIx::Class::Storage::BlockRunner::BEGIN@9
1	1	1	16µs	21µs	DBIx::Class::Storage::BlockRunner::BEGIN@4
1	1	1	12µs	32µs	DBIx::Class::Storage::BlockRunner::BEGIN@10
1	1	1	11µs	34µs	DBIx::Class::Storage::BlockRunner::BEGIN@11
1	1	1	11µs	259µs	DBIx::Class::Storage::BlockRunner::BEGIN@34
1	1	1	11µs	32µs	DBIx::Class::Storage::BlockRunner::BEGIN@12
1	1	1	9µs	45µs	DBIx::Class::Storage::BlockRunner::__ANON__[:29]
1	1	1	8µs	37µs	DBIx::Class::Storage::BlockRunner::BEGIN@8
1	1	1	8µs	15µs	DBIx::Class::Storage::BlockRunner::BEGIN@5
1	1	1	7µs	7µs	DBIx::Class::Storage::BlockRunner::BEGIN@7
2	2	1	2µs	2µs	DBIx::Class::Storage::BlockRunner::storage (xsub)
1	1	1	1µs	1µs	DBIx::Class::Storage::BlockRunner::max_attempts (xsub)
1	1	1	700ns	700ns	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	39µs	2	26µs	# spent 21µs (16+5) within DBIx::Class::Storage::BlockRunner::BEGIN@4 which was called: # once (16µs+5µs) by DBIx::Class::Storage::BEGIN@16 at line 4 use warnings; # spent 21µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@4 # spent 5µs making 1 call to warnings::import
5	2	33µs	2	21µs	# spent 15µs (8+7) within DBIx::Class::Storage::BlockRunner::BEGIN@5 which was called: # once (8µs+7µs) by DBIx::Class::Storage::BEGIN@16 at line 5 use strict; # spent 15µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@5 # spent 7µs making 1 call to strict::import
6
7	2	24µs	1	7µs	# spent 7µs within DBIx::Class::Storage::BlockRunner::BEGIN@7 which was called: # once (7µs+0s) by DBIx::Class::Storage::BEGIN@16 at line 7 use DBIx::Class::Exception; # spent 7µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@7
8	2	32µs	2	66µs	# spent 37µs (8+29) within DBIx::Class::Storage::BlockRunner::BEGIN@8 which was called: # once (8µs+29µs) by DBIx::Class::Storage::BEGIN@16 at line 8 use DBIx::Class::Carp; # spent 37µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@8 # spent 29µs making 1 call to DBIx::Class::Carp::import
9	2	197µs	2	240µs	# spent 216µs (171+45) within DBIx::Class::Storage::BlockRunner::BEGIN@9 which was called: # once (171µs+45µs) by DBIx::Class::Storage::BEGIN@16 at line 9 use Context::Preserve 'preserve_context'; # spent 216µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@9 # spent 24µs making 1 call to Exporter::import
10	2	56µs	2	52µs	# spent 32µs (12+20) within DBIx::Class::Storage::BlockRunner::BEGIN@10 which was called: # once (12µs+20µs) by DBIx::Class::Storage::BEGIN@16 at line 10 use DBIx::Class::_Util qw(is_exception qsub); # spent 32µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@10 # spent 20µs making 1 call to Exporter::import
11	2	53µs	2	57µs	# spent 34µs (11+23) within DBIx::Class::Storage::BlockRunner::BEGIN@11 which was called: # once (11µs+23µs) by DBIx::Class::Storage::BEGIN@16 at line 11 use Scalar::Util qw(weaken blessed reftype); # spent 34µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@11 # spent 23µs making 1 call to Exporter::import
12	2	134µs	2	53µ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 11.0ms (8.67+2.30) within DBIx::Class::Storage::BlockRunner::BEGIN@16 which was called: # once (8.67ms+2.30ms) by DBIx::Class::Storage::BEGIN@16 at line 31 BEGIN {
17	1	5µs			my $initial_fatal_bits = (${^WARNING_BITS}\|\|'') & $warnings::DeadBits{all};
18
19	1	4µs			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	1	1µs			require Sub::Quote;
23	1	700ns			require Sub::Defer;
24	1	123µs			require Moo;
25	1	122µs			require Moo::Object;
26	1	103µs			require Method::Generate::Accessor;
27	1	150µs			require Method::Generate::Constructor;
28
29	3	28µs	3	355µs	# spent 45µs (9+36) within DBIx::Class::Storage::BlockRunner::__ANON__[/usr/share/perl5/DBIx/Class/Storage/BlockRunner.pm:29] which was called: # once (9µs+36µs) by import::into at line 36 of Import/Into.pm Moo->import; # spent 319µs making 1 call to Moo::import # spent 22µs making 1 call to strictures::import # spent 14µs making 1 call to Module::Runtime::use_module
30	1	10µs			${^WARNING_BITS} &= ( $initial_fatal_bits \| ~ $warnings::DeadBits{all} );
31	1	36µs	1	11.0ms	} # spent 11.0ms making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@16
32					# END pre-Moo2 import block
33
34	2	1.44ms	2	507µs	# spent 259µs (11+248) within DBIx::Class::Storage::BlockRunner::BEGIN@34 which was called: # once (11µs+248µs) by DBIx::Class::Storage::BEGIN@16 at line 34 use namespace::clean; # spent 259µs making 1 call to DBIx::Class::Storage::BlockRunner::BEGIN@34 # spent 248µ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	2µs	1	1.50ms	has storage => ( # spent 1.50ms making 1 call to Moo::has
47					is => 'ro',
48					required => 1,
49					);
50
51	1	1µs	1	112µs	has wrap_txn => ( # spent 112µ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	1	4µs	2	127µs	has retry_handler => ( # spent 124µs making 1 call to Moo::has # spent 4µ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	1	2µs	2	4.08ms	has retry_debug => ( # spent 4.08ms making 1 call to Moo::has # spent 1µ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	2µs	1	156µs	has max_attempts => ( # spent 156µs making 1 call to Moo::has
74					is => 'ro',
75					default => 20,
76					);
77
78	1	4µs	2	339µs	has failed_attempt_count => ( # spent 337µs making 1 call to Moo::has # spent 3µ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	1	3µs	2	272µs	has exception_stack => ( # spent 271µ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 34.9ms (1.62+33.3) within DBIx::Class::Storage::BlockRunner::run which was called 89 times, avg 393µs/call: # 89 times (1.62ms+33.3ms) by DBIx::Class::Storage::DBI::dbh_do at line 855 of DBIx/Class/Storage/DBI.pm, avg 393µs/call sub run {
105	89	30µs			my $self = shift;
106
107	89	259µs	89	599µs	$self->_reset_exception_stack; # spent 599µs making 89 calls to DBIx::Class::Storage::BlockRunner::_reset_exception_stack, avg 7µs/call
108	89	330µs	89	1.33ms	$self->_set_failed_attempt_count(0); # spent 1.33ms making 89 calls to DBIx::Class::Storage::BlockRunner::_set_failed_attempt_count, avg 15µs/call
109
110	89	30µs			my $cref = shift;
111
112	89	278µs	89	84µs	$self->throw_exception('run() requires a coderef to execute as its first argument') # spent 84µs making 89 calls to Scalar::Util::reftype, avg 948ns/call
113					if ( reftype($cref)\|\|'' ) ne 'CODE';
114
115	89	113µs	1	1µs	my $storage = $self->storage; # spent 1µs making 1 call to DBIx::Class::Storage::BlockRunner::storage
116
117	89	66µs			return $cref->( @_ ) if (
118					$storage->{_in_do_block}
119					and
120					! $self->wrap_txn
121					);
122
123	89	87µs			local $storage->{_in_do_block} = 1 unless $storage->{_in_do_block};
124
125	89	356µs	89	31.3ms	return $self->_run($cref, @_); # spent 31.3ms making 89 calls to DBIx::Class::Storage::BlockRunner::_run, avg 352µs/call
126					}
127
128					# this is the actual recursing worker
129					# spent 31.3ms (1.54+29.7) within DBIx::Class::Storage::BlockRunner::_run which was called 89 times, avg 352µs/call: # 89 times (1.54ms+29.7ms) by DBIx::Class::Storage::BlockRunner::run at line 125, avg 352µ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	89	393µs	89	128µs	weaken( my $self = shift ); # spent 128µs making 89 calls to Scalar::Util::weaken, avg 1µs/call
133	89	219µs	89	64µs	weaken( my $cref = shift ); # spent 64µs making 89 calls to Scalar::Util::weaken, avg 722ns/call
134
135	89	69µ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	89	106µs	1	700ns	my $txn_init_depth = $self->wrap_txn ? $self->storage->transaction_depth : undef; # spent 700ns making 1 call to DBIx::Class::Storage::BlockRunner::wrap_txn
140	89	11µs			my $txn_begin_ok;
141
142	89	38µs			my $run_err = '';
143
144					# spent 20.9ms (789µs+20.1) within DBIx::Class::Storage::BlockRunner::__ANON__[/usr/share/perl5/DBIx/Class/Storage/BlockRunner.pm:155] which was called 89 times, avg 235µs/call: # 88 times (777µs+19.7ms) by Context::Preserve::preserve_context at line 32 of Context/Preserve.pm, avg 233µs/call # once (12µs+418µs) by Context::Preserve::preserve_context at line 22 of Context/Preserve.pm return preserve_context {
145					try {
146	89	23µs			if (defined $txn_init_depth) {
147					$self->storage->txn_begin;
148					$txn_begin_ok = 1;
149					}
150	89	135µs	89	17.1ms	$cref->( @$args ); # spent 17.1ms making 89 calls to DBIx::Class::Storage::DBI::__ANON__[DBIx/Class/Storage/DBI.pm:855], avg 192µs/call
151					} catch {
152					$run_err = $_;
153					(); # important, affects @_ below
154	89	2.82ms	178	20.1ms	}; # spent 19.6ms making 89 calls to Try::Tiny::try, avg 220µs/call # spent 541µs making 89 calls to Try::Tiny::catch, avg 6µs/call
155					# spent 1.29ms (716µs+571µs) within DBIx::Class::Storage::BlockRunner::__ANON__[/usr/share/perl5/DBIx/Class/Storage/BlockRunner.pm:233] which was called 89 times, avg 14µs/call: # 88 times (702µs+563µs) by Context::Preserve::preserve_context at line 37 of Context/Preserve.pm, avg 14µs/call # once (14µs+8µs) by Context::Preserve::preserve_context at line 27 of Context/Preserve.pm } replace => sub {
156	89	59µs			my @res = @_;
157
158	89	97µs	1	900ns	my $storage = $self->storage; # spent 900ns making 1 call to DBIx::Class::Storage::BlockRunner::storage
159	89	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	89	34µ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	89	248µs	89	570µs	if ( is_exception $run_err ) { # spent 570µs making 89 calls to DBIx::Class::_Util::is_exception, avg 6µ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	89	5.95ms			return wantarray ? @res : $res[0];
233	89	921µs	89	29.6ms	}; # spent 29.6ms making 89 calls to Context::Preserve::preserve_context, avg 332µ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	16µs	1	382µs	1; # spent 382µs making 1 call to B::Hooks::EndOfScope::XS::__ANON__

					# spent 1µs within DBIx::Class::Storage::BlockRunner::max_attempts which was called: # once (1µ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 2µs within DBIx::Class::Storage::BlockRunner::storage which was called 2 times, avg 950ns/call: # once (1µs+0s) by DBIx::Class::Storage::BlockRunner::run at line 115 # once (900ns+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 700ns within DBIx::Class::Storage::BlockRunner::wrap_txn which was called: # once (700ns+0s) by DBIx::Class::Storage::BlockRunner::_run at line 139 sub DBIx::Class::Storage::BlockRunner::wrap_txn; # xsub