File | /data/SimpleDB-Client/author.t/../lib/SimpleDB/Client.pm |
Statements Executed | 147 |
Statement Execution Time | 2.47ms |
Calls | P | F | Exclusive Time |
Inclusive Time |
Subroutine |
---|---|---|---|---|---|
1 | 1 | 1 | 10.6ms | 11.7ms | BEGIN@47 | SimpleDB::Client::
1 | 1 | 1 | 4.71ms | 83.5ms | BEGIN@49 | SimpleDB::Client::
1 | 1 | 1 | 3.81ms | 24.7ms | BEGIN@48 | SimpleDB::Client::
1 | 1 | 1 | 1.86ms | 350ms | BEGIN@46 | SimpleDB::Client::
1 | 1 | 1 | 485µs | 1.21ms | BEGIN@51 | SimpleDB::Client::
3 | 1 | 1 | 418µs | 2.29ms | construct_request | SimpleDB::Client::
3 | 3 | 1 | 264µs | 367ms | send_request | SimpleDB::Client::
1 | 1 | 1 | 171µs | 18.9ms | BEGIN@53 | SimpleDB::Client::
3 | 1 | 1 | 67µs | 550µs | handle_response | SimpleDB::Client::
3 | 1 | 1 | 13µs | 13µs | __ANON__[../lib/SimpleDB/Client.pm:160] | SimpleDB::Client::
3 | 1 | 2 | 13µs | 13µs | CORE:sort (opcode) | SimpleDB::Client::
1 | 1 | 1 | 12µs | 170µs | BEGIN@331 | SimpleDB::Client::
1 | 1 | 1 | 12µs | 62µs | BEGIN@52 | SimpleDB::Client::
1 | 1 | 1 | 9µs | 9µs | BEGIN@54 | SimpleDB::Client::
1 | 1 | 1 | 9µs | 8.99ms | __ANON__[../lib/SimpleDB/Client.pm:133] | SimpleDB::Client::
1 | 1 | 1 | 8µs | 8µs | BEGIN@50 | SimpleDB::Client::
1 | 1 | 1 | 7µs | 5.56ms | __ANON__[../lib/SimpleDB/Client.pm:120] | SimpleDB::Client::
Line | State ments |
Time on line |
Calls | Time in subs |
Code |
---|---|---|---|---|---|
1 | package SimpleDB::Client; | ||||
2 | |||||
3 | =head1 NAME | ||||
4 | |||||
5 | SimpleDB::Client - The network interface to the SimpleDB service. | ||||
6 | |||||
7 | =head1 SYNOPSIS | ||||
8 | |||||
9 | use SimpleDB::Client; | ||||
10 | |||||
11 | my $sdb = SimpleDB::Client->new(secret_key=>'abc', access_key=>'123'); | ||||
12 | |||||
13 | # create a domain | ||||
14 | my $hashref = $sdb->send_request('CreateDomain', {DomainName => 'my_things'}); | ||||
15 | |||||
16 | # insert attributes | ||||
17 | my $hashref = $sdb->send_request('PutAttributes', { | ||||
18 | DomainName => 'my_things', | ||||
19 | ItemName => 'car', | ||||
20 | 'Attribute.1.Name' => 'color', | ||||
21 | 'Attribute.1.Value' => 'red', | ||||
22 | 'Attribute.1.Replace' => 'true', | ||||
23 | }); | ||||
24 | |||||
25 | # get attributes | ||||
26 | my $hashref = $sdb->send_request('GetAttributes', { | ||||
27 | DomainName => 'my_things', | ||||
28 | ItemName => 'car', | ||||
29 | }); | ||||
30 | |||||
31 | # search attributes | ||||
32 | my $hashref = $sdb->send_request('Select', { | ||||
33 | SelectExpression => q{select * from my_things where color = 'red'}, | ||||
34 | }); | ||||
35 | |||||
36 | =head1 DESCRIPTION | ||||
37 | |||||
38 | This class will let you quickly and easily inteface with AWS SimpleDB. It throws exceptions from L<SimpleDB::Client::Exception>. It's very light weight. Although we haven't run any benchmarks on the other modules, it should outperform any of the other Perl modules that exist today. | ||||
39 | |||||
40 | =head1 METHODS | ||||
41 | |||||
42 | The following methods are available from this class. | ||||
43 | |||||
44 | =cut | ||||
45 | |||||
46 | 3 | 131µs | 2 | 353ms | # spent 350ms (1.86+348) within SimpleDB::Client::BEGIN@46 which was called
# once (1.86ms+348ms) by main::BEGIN@2 at line 46 # spent 350ms making 1 call to SimpleDB::Client::BEGIN@46
# spent 2.85ms making 1 call to Moose::Exporter::__ANON__[Moose/Exporter.pm:389] |
47 | 3 | 172µs | 2 | 11.8ms | # spent 11.7ms (10.6+1.10) within SimpleDB::Client::BEGIN@47 which was called
# once (10.6ms+1.10ms) by main::BEGIN@2 at line 47 # spent 11.7ms making 1 call to SimpleDB::Client::BEGIN@47
# spent 97µs making 1 call to Exporter::import |
48 | 3 | 139µs | 2 | 24.7ms | # spent 24.7ms (3.81+20.9) within SimpleDB::Client::BEGIN@48 which was called
# once (3.81ms+20.9ms) by main::BEGIN@2 at line 48 # spent 24.7ms making 1 call to SimpleDB::Client::BEGIN@48
# spent 38µs making 1 call to Exporter::import |
49 | 3 | 168µs | 1 | 83.5ms | # spent 83.5ms (4.71+78.8) within SimpleDB::Client::BEGIN@49 which was called
# once (4.71ms+78.8ms) by main::BEGIN@2 at line 49 # spent 83.5ms making 1 call to SimpleDB::Client::BEGIN@49 |
50 | 3 | 25µs | 1 | 8µs | # spent 8µs within SimpleDB::Client::BEGIN@50 which was called
# once (8µs+0s) by main::BEGIN@2 at line 50 # spent 8µs making 1 call to SimpleDB::Client::BEGIN@50 |
51 | 3 | 92µs | 2 | 1.46ms | # spent 1.21ms (485µs+727µs) within SimpleDB::Client::BEGIN@51 which was called
# once (485µs+727µs) by main::BEGIN@2 at line 51 # spent 1.21ms making 1 call to SimpleDB::Client::BEGIN@51
# spent 248µs making 1 call to Time::HiRes::import |
52 | 3 | 27µs | 2 | 113µs | # spent 62µs (12+50) within SimpleDB::Client::BEGIN@52 which was called
# once (12µs+50µs) by main::BEGIN@2 at line 52 # spent 62µs making 1 call to SimpleDB::Client::BEGIN@52
# spent 50µs making 1 call to Exporter::import |
53 | 3 | 138µs | 1 | 18.9ms | # spent 18.9ms (171µs+18.8) within SimpleDB::Client::BEGIN@53 which was called
# once (171µs+18.8ms) by main::BEGIN@2 at line 53 # spent 18.9ms making 1 call to SimpleDB::Client::BEGIN@53 |
54 | 3 | 704µs | 1 | 9µs | # spent 9µs within SimpleDB::Client::BEGIN@54 which was called
# once (9µs+0s) by main::BEGIN@2 at line 54 # spent 9µs making 1 call to SimpleDB::Client::BEGIN@54 |
55 | |||||
56 | #-------------------------------------------------------- | ||||
57 | |||||
58 | =head2 new ( params ) | ||||
59 | |||||
60 | =head3 params | ||||
61 | |||||
62 | A hash containing the parameters to pass in to this method. | ||||
63 | |||||
64 | =head4 access_key | ||||
65 | |||||
66 | The access key given to you from Amazon when you sign up for the SimpleDB service at this URL: L<http://aws.amazon.com/simpledb/> | ||||
67 | |||||
68 | =head4 secret_key | ||||
69 | |||||
70 | The secret access key given to you from Amazon. | ||||
71 | |||||
72 | =head4 simpledb_uri | ||||
73 | |||||
74 | The constructor that SimpleDB::Client will connect to. Defaults to: | ||||
75 | |||||
76 | URI->new('https://sdb.amazonaws.com/') | ||||
77 | |||||
78 | =cut | ||||
79 | |||||
80 | #-------------------------------------------------------- | ||||
81 | |||||
82 | =head2 access_key ( ) | ||||
83 | |||||
84 | Returns the access key passed to the constructor. | ||||
85 | |||||
86 | =cut | ||||
87 | |||||
88 | 1 | 3µs | 1 | 2.32ms | has 'access_key' => ( # spent 2.32ms making 1 call to Moose::has |
89 | is => 'ro', | ||||
90 | required => 1, | ||||
91 | documentation => 'The AWS SimpleDB access key id provided by Amazon.', | ||||
92 | ); | ||||
93 | |||||
94 | #-------------------------------------------------------- | ||||
95 | |||||
96 | =head2 secret_key ( ) | ||||
97 | |||||
98 | Returns the secret key passed to the constructor. | ||||
99 | |||||
100 | =cut | ||||
101 | |||||
102 | 1 | 2µs | 1 | 1.07ms | has 'secret_key' => ( # spent 1.07ms making 1 call to Moose::has |
103 | is => 'ro', | ||||
104 | required => 1, | ||||
105 | documentation => 'The AWS SimpleDB secret access key id provided by Amazon.', | ||||
106 | ); | ||||
107 | |||||
108 | #-------------------------------------------------------- | ||||
109 | |||||
110 | =head2 simpledb_uri ( ) | ||||
111 | |||||
112 | Returns the L<URI> object passed into the constructor that SimpleDB::Client will connect to. Defaults to: | ||||
113 | |||||
114 | URI->new('https://sdb.amazonaws.com/') | ||||
115 | |||||
116 | =cut | ||||
117 | |||||
118 | has simpledb_uri => ( | ||||
119 | is => 'ro', | ||||
120 | 1 | 7µs | 1 | 5.55ms | # spent 5.56ms (7µs+5.55) within SimpleDB::Client::__ANON__[../lib/SimpleDB/Client.pm:120] which was called
# once (7µs+5.55ms) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm # spent 5.55ms making 1 call to URI::new |
121 | 1 | 4µs | 1 | 908µs | ); # spent 908µs making 1 call to Moose::has |
122 | |||||
123 | #-------------------------------------------------------- | ||||
124 | |||||
125 | =head2 user_agent ( ) | ||||
126 | |||||
127 | Returns the L<LWP::UserAgent> object that is used to connect to SimpleDB. It's cached here so it doesn't have to be created each time. | ||||
128 | |||||
129 | =cut | ||||
130 | |||||
131 | has user_agent => ( | ||||
132 | is => 'ro', | ||||
133 | 1 | 10µs | 1 | 8.98ms | # spent 8.99ms (9µs+8.98) within SimpleDB::Client::__ANON__[../lib/SimpleDB/Client.pm:133] which was called
# once (9µs+8.98ms) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm # spent 8.98ms making 1 call to LWP::UserAgent::new |
134 | 1 | 3µs | 1 | 861µs | ); # spent 861µs making 1 call to Moose::has |
135 | |||||
136 | #-------------------------------------------------------- | ||||
137 | |||||
138 | =head2 construct_request ( action, [ params ] ) | ||||
139 | |||||
140 | Returns a string that contains the HTTP post data ready to make a request to SimpleDB. Normally this is only called by send_request(), but if you want to debug a SimpleDB interaction, then having access to this method is critical. | ||||
141 | |||||
142 | =head3 action | ||||
143 | |||||
144 | The action to perform on SimpleDB. See the "Operations" section of the guide located at L<http://docs.amazonwebservices.com/AmazonSimpleDB/2009-04-15/DeveloperGuide/>. | ||||
145 | |||||
146 | =head3 params | ||||
147 | |||||
148 | Any extra prameters required by the operation. The normal parameters of Action, AWSAccessKeyId, Version, Timestamp, SignatureMethod, SignatureVersion, and Signature are all automatically provided by this method. | ||||
149 | |||||
150 | =cut | ||||
151 | |||||
152 | # spent 2.29ms (418µs+1.88) within SimpleDB::Client::construct_request which was called 3 times, avg 764µs/call:
# 3 times (418µs+1.88ms) by SimpleDB::Client::send_request at line 203, avg 764µs/call | ||||
153 | 3 | 4µs | my ($self, $action, $params) = @_; | ||
154 | 3 | 2µs | my $encoding_pattern = "^A-Za-z0-9\-_.~"; | ||
155 | |||||
156 | # add required parameters | ||||
157 | 3 | 4µs | $params->{'Action'} = $action; | ||
158 | 3 | 10µs | 3 | 12µs | $params->{'AWSAccessKeyId'} = $self->access_key; # spent 12µs making 3 calls to SimpleDB::Client::access_key, avg 4µs/call |
159 | 3 | 3µs | $params->{'Version'} = '2009-04-15'; | ||
160 | 6 | 75µs | 3 | 13µs | # spent 13µs within SimpleDB::Client::__ANON__[../lib/SimpleDB/Client.pm:160] which was called 3 times, avg 4µs/call:
# 3 times (13µs+0s) by SimpleDB::Client::construct_request at line 160, avg 4µs/call # spent 13µs making 3 calls to SimpleDB::Client::__ANON__[../lib/SimpleDB/Client.pm:160], avg 4µs/call |
161 | 3 | 4µs | $params->{'SignatureMethod'} = 'HmacSHA256'; | ||
162 | 3 | 2µs | $params->{'SignatureVersion'} = 2; | ||
163 | |||||
164 | # construct post data | ||||
165 | 3 | 700ns | my $post_data; | ||
166 | 3 | 37µs | 3 | 13µs | foreach my $name (sort {$a cmp $b} keys %{$params}) { # spent 13µs making 3 calls to SimpleDB::Client::CORE:sort, avg 4µs/call |
167 | 20 | 61µs | 20 | 576µs | $post_data .= $name . '=' . uri_escape_utf8($params->{$name}, $encoding_pattern) . '&'; # spent 576µs making 20 calls to URI::Escape::uri_escape_utf8, avg 29µs/call |
168 | } | ||||
169 | 3 | 3µs | chop $post_data; | ||
170 | |||||
171 | # sign the post data | ||||
172 | 3 | 26µs | 6 | 160µs | my $signature = "POST\n".$self->simpledb_uri->host."\n/\n". $post_data; # spent 148µs making 3 calls to URI::_server::host, avg 49µs/call
# spent 13µs making 3 calls to SimpleDB::Client::simpledb_uri, avg 4µs/call |
173 | 3 | 114µs | 6 | 102µs | $signature = hmac_sha256_base64($signature, $self->secret_key) . '='; # spent 89µs making 3 calls to Digest::SHA::hmac_sha256_base64, avg 30µs/call
# spent 13µs making 3 calls to SimpleDB::Client::secret_key, avg 4µs/call |
174 | 3 | 8µs | 3 | 94µs | $post_data .= '&Signature=' . uri_escape_utf8($signature, $encoding_pattern); # spent 94µs making 3 calls to URI::Escape::uri_escape_utf8, avg 31µs/call |
175 | |||||
176 | 3 | 35µs | 9 | 742µs | my $request = HTTP::Request->new('POST', $self->simpledb_uri->as_string); # spent 724µs making 3 calls to HTTP::Request::new, avg 241µs/call
# spent 12µs making 3 calls to URI::as_string, avg 4µs/call
# spent 7µs making 3 calls to SimpleDB::Client::simpledb_uri, avg 2µs/call |
177 | 3 | 17µs | 3 | 49µs | $request->content_type("application/x-www-form-urlencoded; charset=utf-8"); # spent 28µs making 2 calls to HTTP::Message::__ANON__[HTTP/Message.pm:622], avg 14µs/call
# spent 20µs making 1 call to HTTP::Message::AUTOLOAD |
178 | 3 | 10µs | 3 | 83µs | $request->content($post_data); # spent 83µs making 3 calls to HTTP::Message::content, avg 28µs/call |
179 | |||||
180 | 3 | 15µs | return $request; | ||
181 | } | ||||
182 | |||||
183 | #-------------------------------------------------------- | ||||
184 | |||||
185 | =head2 send_request ( action, [ params ] ) | ||||
186 | |||||
187 | Creates a request, and then sends it to SimpleDB. The response is returned as a hash reference of the raw XML document returned by SimpleDB. Automatically attempts 5 cascading retries on connection failure. | ||||
188 | |||||
189 | Throws SimpleDB::Client::Exception::Response and SimpleDB::Client::Exception::Connection. | ||||
190 | |||||
191 | =head3 action | ||||
192 | |||||
193 | See create_request() for details. | ||||
194 | |||||
195 | =head3 params | ||||
196 | |||||
197 | See create_request() for details. | ||||
198 | |||||
199 | =cut | ||||
200 | |||||
201 | # spent 367ms (264µs+367) within SimpleDB::Client::send_request which was called 3 times, avg 122ms/call:
# once (191µs+204ms) by main::RUNTIME at line 15 of 01.HTTP.t
# once (37µs+103ms) by main::RUNTIME at line 25 of 01.HTTP.t
# once (36µs+59.8ms) by main::RUNTIME at line 17 of 01.HTTP.t | ||||
202 | 3 | 4µs | my ($self, $action, $params) = @_; | ||
203 | 3 | 9µs | 3 | 2.29ms | my $request = $self->construct_request($action, $params); # spent 2.29ms making 3 calls to SimpleDB::Client::construct_request, avg 764µs/call |
204 | # loop til we get a response or throw an exception | ||||
205 | 3 | 4µs | foreach my $retry (1..5) { | ||
206 | |||||
207 | # make the request | ||||
208 | 3 | 11µs | 3 | 13µs | my $ua = $self->user_agent; # spent 13µs making 3 calls to SimpleDB::Client::user_agent, avg 4µs/call |
209 | 3 | 9µs | 3 | 364ms | my $response = $ua->request($request); # spent 364ms making 3 calls to LWP::UserAgent::request, avg 121ms/call |
210 | |||||
211 | # got a possibly recoverable error, let's retry | ||||
212 | 3 | 10µs | 3 | 20µs | if ($response->code >= 500 && $response->code < 600) { # spent 20µs making 3 calls to HTTP::Response::code, avg 7µs/call |
213 | if ($retry < 5) { | ||||
214 | usleep((4 ** $retry) * 100_000); | ||||
215 | } | ||||
216 | else { | ||||
217 | warn $response->header('Reason'); | ||||
218 | SimpleDB::Client::Exception::Connection->throw(error=>'Exceeded maximum retries.', status_code=>$response->code); | ||||
219 | } | ||||
220 | } | ||||
221 | |||||
222 | # not a retry | ||||
223 | else { | ||||
224 | 3 | 205µs | 3 | 550µs | return $self->handle_response($response); # spent 550µs making 3 calls to SimpleDB::Client::handle_response, avg 183µs/call |
225 | } | ||||
226 | } | ||||
227 | } | ||||
228 | |||||
229 | #-------------------------------------------------------- | ||||
230 | |||||
231 | =head2 handle_response ( response ) | ||||
232 | |||||
233 | Returns a hashref containing the response from SimpleDB. | ||||
234 | |||||
235 | Throws SimpleDB::Client::Exception::Response. | ||||
236 | |||||
237 | =head3 response | ||||
238 | |||||
239 | The L<HTTP::Response> object created by the C<send_request> method. | ||||
240 | |||||
241 | =cut | ||||
242 | |||||
243 | # spent 550µs (67+483) within SimpleDB::Client::handle_response which was called 3 times, avg 183µs/call:
# 3 times (67µs+483µs) by SimpleDB::Client::send_request at line 224, avg 183µs/call | ||||
244 | 3 | 3µs | my ($self, $response) = @_; | ||
245 | 6 | 43µs | 9 | 464µs | my $content = eval {XML::Bare::xmlin($response->content)}; # spent 424µs making 3 calls to XML::Bare::xmlin, avg 142µs/call
# spent 24µs making 3 calls to HTTP::Message::content, avg 8µs/call
# spent 16µs making 3 calls to XML::Bare::DESTROY, avg 5µs/call |
246 | |||||
247 | # choked reconstituing the XML, probably because it wasn't XML | ||||
248 | 3 | 22µs | 3 | 35µs | if ($@) { # spent 35µs making 3 calls to HTTP::Response::is_success, avg 12µs/call |
249 | SimpleDB::Client::Exception::Response->throw( | ||||
250 | error => 'Response was garbage. Confirm Net::SSLeay, XML::Parser, and XML::Simple installations.', | ||||
251 | status_code => $response->code, | ||||
252 | response => $response, | ||||
253 | ); | ||||
254 | } | ||||
255 | |||||
256 | # got a valid response | ||||
257 | elsif ($response->is_success) { | ||||
258 | return $content; | ||||
259 | } | ||||
260 | |||||
261 | # SimpleDB gave us an error message | ||||
262 | else { | ||||
263 | SimpleDB::Client::Exception::Response->throw( | ||||
264 | error => $content->{Errors}{Error}{Message}, | ||||
265 | status_code => $response->code, | ||||
266 | error_code => $content->{Errors}{Error}{Code}, | ||||
267 | box_usage => $content->{Errors}{Error}{BoxUsage}, | ||||
268 | request_id => $content->{RequestID}, | ||||
269 | response => $response, | ||||
270 | ); | ||||
271 | } | ||||
272 | } | ||||
273 | |||||
274 | =head1 PREREQS | ||||
275 | |||||
276 | This package requires the following modules: | ||||
277 | |||||
278 | L<XML::Simple> | ||||
279 | L<LWP> | ||||
280 | L<Time::HiRes> | ||||
281 | L<Crypt::SSLeay> | ||||
282 | L<Moose> | ||||
283 | L<Digest::SHA> | ||||
284 | L<URI> | ||||
285 | L<Exception::Class> | ||||
286 | |||||
287 | =head1 SUPPORT | ||||
288 | |||||
289 | =over | ||||
290 | |||||
291 | =item Repository | ||||
292 | |||||
293 | L<http://github.com/rizen/SimpleDB-Client> | ||||
294 | |||||
295 | =item Bug Reports | ||||
296 | |||||
297 | L<http://rt.cpan.org/Public/Dist/Display.html?Name=SimpleDB-Client> | ||||
298 | |||||
299 | =back | ||||
300 | |||||
301 | =head1 SEE ALSO | ||||
302 | |||||
303 | There are other packages you can use to access SimpleDB. I chose not to use them because I wanted something a bit more lightweight that I could build L<SimpleDB::Class> on top of so I could easily map objects to SimpleDB Domain Items. If you're looking for a low level SimpleDB accessor and for some reason this module doesn't cut the mustard, then you should check out these: | ||||
304 | |||||
305 | =over | ||||
306 | |||||
307 | =item Amazon::SimpleDB (L<http://developer.amazonwebservices.com/connect/entry.jspa?externalID=1136>) | ||||
308 | |||||
309 | A complete and nicely functional low level library made by Amazon itself. | ||||
310 | |||||
311 | =item L<Amazon::SimpleDB> | ||||
312 | |||||
313 | A low level SimpleDB accessor that's in its infancy and may be abandoned, but appears to be pretty functional, and of the same scope as Amazon's own module. | ||||
314 | |||||
315 | =back | ||||
316 | |||||
317 | In addition to clients, there is at least one other API compatible server out there that basically lets you host your own SimpleDB if you don't want to put it in Amazon's cloud. It's called M/DB. You can read more about it here: L<http://gradvs1.mgateway.com/main/index.html?path=mdb>. Though I haven't tested it, since it's API compatible, you should be able to use it with both this module and L<SimpleDB::Class>. | ||||
318 | |||||
319 | =head1 AUTHOR | ||||
320 | |||||
321 | JT Smith <jt_at_plainblack_com> | ||||
322 | |||||
323 | I have to give credit where credit is due: SimpleDB::Client is heavily inspired by the Amazon::SimpleDB class distributed by Amazon itself (not to be confused with L<Amazon::SimpleDB> written by Timothy Appnel). | ||||
324 | |||||
325 | =head1 LEGAL | ||||
326 | |||||
327 | SimpleDB::Client is Copyright 2009-2010 Plain Black Corporation (L<http://www.plainblack.com/>) and is licensed under the same terms as Perl itself. | ||||
328 | |||||
329 | =cut | ||||
330 | |||||
331 | 3 | 59µs | 2 | 327µs | # spent 170µs (12+157) within SimpleDB::Client::BEGIN@331 which was called
# once (12µs+157µs) by main::BEGIN@2 at line 331 # spent 170µs making 1 call to SimpleDB::Client::BEGIN@331
# spent 157µs making 1 call to Moose::Exporter::__ANON__[Moose/Exporter.pm:478] |
332 | 1 | 33µs | 2 | 14.2ms | __PACKAGE__->meta->make_immutable; # spent 14.2ms making 1 call to Class::MOP::Class::make_immutable
# spent 12µs making 1 call to SimpleDB::Client::meta |
# spent 13µs within SimpleDB::Client::CORE:sort which was called 3 times, avg 4µs/call:
# 3 times (13µs+0s) by SimpleDB::Client::construct_request at line 166 of ../lib/SimpleDB/Client.pm, avg 4µs/call |