The document describes using Log::Minimal to log messages with timestamps, severity levels, and stack traces. Log::Minimal provides functions like debugf(), infof(), warnf() that log messages, and configuration options like AUTODUMP and PRINT to customize the output format. It can be used to log messages from multi-threaded or distributed applications.

20. print STDERR “timeoutn”;
timeout
warn(“timeout”);
timeout at test.pl line 8.

21. sub logf {
my ($level,$message) = @_;
my ($pkg,$file,$line) = caller;
my @time = localtime;
warn sprintf "%04d-%02d-%02dT%02d:%02d:%02d
[%s] %s at %s line %d.n",
$time[5]+1900, $time[4]+1, @time[3,2,1,0],
$level, $message,
$file, $line;
}
logf(“WARN”,”timeout”);
logf(“INFO”,”foo bar”);
2011-10-05T09:41:30 [WARN] timeout at test.pl line 10.
2011-10-05T09:41:30 [INFO] foo bar at test.pl line 11.

22. ➔

24. 2011-10-05T09:41:30
[WARN]
[/entry/foobar]
failed request: http://ad.net/ read timeout
at /path/to/Controler/Entry.pm line 10.

28. use Log::Minimal;
# stack trace
debugf(‘blah blah blah’);
infof(“server start $$”);
critf("%s","foo");
warnf("%d %s", 1, "foo");
# stack trace
debugff(‘blah blah blah’);
infoff(“server start $$”);
critff("%s","foo");
warnff("%d %s", 1, "foo");

29. use Log::Minimal;
debugf(‘blah blah blah’); #
local $ENV{LM_DEBUG} = 1;
debugf(‘blah blah blah’); #
2011-10-05T09:41:30 [DEBUG] blah.. at test.pl line 11.

30. #
local $Log::Minimal::PRINT = sub {
my ( $time, $type, $message, $trace) = @_;
warn(“$time [$type] $message $tracen”);
};
#
open( my $fh, ">>", "app.log");
local $Log::Minimal::PRINT = sub {
my ( $time, $type, $msg, $tr, $r_msg ) = @_;
print $fh “$time [$type] $r_msg $trn”;
};

31. #
local $Log::Minimal::AUTODUMP = 1;
warnf(“response => %s”,$res);
2011-05-11T15:56:14 [WARN] response => [200,
['Content-Type','text/plain'],['OK']] at ..
#
local $Log::Minimal::COLOR = 1;
warnf(“hirose31”);
2011-05-11T15:56:14 [WARN] hirose31 at ..

37. use Log::Minimal;
use Plack::Builder;
builder {
enable "Log::Minimal", autodump => 1;
sub {
my $env = shift;
warnf("warn");
debugf("debug");
...
}
};
$ plackup -a demo.psgi
2011-05-11T16:32:24 [WARN] [/foo/bar/baz] warn at /tmp/
demo.psgi line 8
2011-05-11T16:32:24 [DEBUG] [/foo/bar/baz] debug at /tmp/
demo.psgi line 9

38. use Log::Minimal;
use Parallel::Prefork;
my $pm = Parallel::Prefork->new();
while ( $pm->signal_received ne 'TERM' ) {
$pm->start(sub {
local $Log::Minimal::AUTODUMP = 1;
local $Log::Minimal::COLOR = 1;
while (1) {
my $job = $queue->dequeue;
local $Log::Minimal::PRINT = sub {
my ( $time, $type, $message, $trace) = @_;
warn(“$$ [“,$job->name,”] [$type] $message $trace”);
};
...
}
});
}

44. SELECT * FROM entries
WHERE created_at >= '2011-10-05 00:00:00'
AND created_at < '2011-10-06 00:00:00'
AND status != 0;
Data::Entry->search({
-and => [
created_at => {'>=','2011-10-05 00:00:00' },
created_at => {'<','2011-10-06 00:00:00' },
],
status => { '!=', 0 }
});

45. SELECT * FROM entries
WHERE created_at >= '2011-10-05 00:00:00'
AND created_at < '2011-10-06 00:00:00'
AND status != 0;
Data::Entry->search({
-and => [
created_at => {'>=','2011-10-05 00:00:00' },
created_at => {'<','2011-10-06 00:00:00' },
],
status => { '!=', 0 }
});

46. SELECT * FROM entries
WHERE created_at >= '2011-10-05 00:00:00'
AND created_at < '2011-10-06 00:00:00'
AND status != 0;
Data::Entry->search({
-and => [
created_at => {'>=','2011-10-05 00:00:00' },
created_at => {'<','2011-10-06 00:00:00' },
],
status => { '!=', 0 }
});

50. my $dbh = DBIx::Sunny->connect(
‘dsn’,‘user’,‘passwd’,
);
✓ RaiseError => 1
✓ PrintError= > 0
✓ ShowErrorStatement => 1
✓ AutoInactiveDestroy => 1
✓ sqlite_unicode/mysql_enable_utf8 => 1
✓ mysql_auto_reconnect => 0

51. my $sth = $dbh->prepare(“SELECT *
FROM entries
WHERE ..”);
SELECT /* test.pl line 941 */ *
FROM entries
WHERE ..

52. selectrow_arrayref($query, {}, @bind);
selectrow_hashref($query, {}, @bind);
selectall_arrayref($query, { Slice => {} }, @bind);
prepare($query) && execute(@bind)

53. my $builder = SQL::Maker->new(
driver => 'mysql',
);
my $dbh = DBIx::Sunny->connect(...);
my ($sql, @binds) = $builder->select(
'user',
['*'],
{name => 'john'},
{order_by => 'user_id DESC'}
);
my $rows = $dbh->select_row($sql,@binds);

55. my $dbh = DBI->connect($dsn,$user,$pass,{...});
while ( my $job = $queue->dequeue ) {
....
}
my $DBH;
sub get_dbh {
$DBH ||= DBI->connect($dsn,$user,$pass,{...});
$DBH;
}
while ( my $job = $queue->dequeue ) {
my $dbh = get_dbh();
....
}
sub get_dbh {
DBI->connect_cached($dsn,$user,$pass,{...});
}
while ( my $job = $queue->dequeue ) {
my $dbh = get_dbh();
....
}

56. my $dbh = DBI->connect($dsn,$user,$pass,{...});
while ( my $job = $queue->dequeue ) {
....
}
my $DBH;
sub get_dbh {
$DBH ||= DBI->connect($dsn,$user,$pass,{...});
$DBH;
}
while ( my $job = $queue->dequeue ) {
my $dbh = get_dbh();
....
}
sub get_dbh {
DBI->connect_cached($dsn,$user,$pass,{...});
}
while ( my $job = $queue->dequeue ) {
my $dbh = get_dbh();
....
}

57. > SHOW PROCESSLIST;
+--------+-------------+--------------------+---------+---------+-------+----------+------+
| Id | User | Host | db | Command | Time | State | Info |
+--------+-------------+--------------------+---------+---------+-------+----------+------+
| 1 | system user | | NULL | Connect | 4851 | Wait... | NULL |
| 2 | system user | | NULL | Connect | 1 | Has r... | NULL |
| 235873 | www-slave | 10.0.xxx.39:33018 | cluster | Sleep | 8 | | NULL |
| 278334 | www-slave | 10.0.xxx.39:37627 | cluster | Sleep | 1206 | | NULL |
| 365403 | www-slave | 10.0.xxx.39:43957 | cluster | Sleep | 1259 | | NULL |
| 378019 | www-slave | 10.0.xxx.39:45098 | cluster | Sleep | 138 | | NULL |
| 397336 | www-slave | 10.0.xxx.39:48595 | cluster | Sleep | 377 | | NULL |
| 404611 | www-slave | 10.0.xxx.206:60525 | cluster | Sleep | 44 | | NULL |
| 405048 | www-slave | 10.0.xxx.206:60645 | cluster | Sleep | 119 | | NULL |
| 405091 | www-slave | 10.0.xxx.58:51982 | cluster | Sleep | 1104 | | NULL |
.....
811 rows in set (0.00 sec)

60. my $sc = start_scope_container(); #
scope_container(‘key1’,‘value1’);
$value = scope_container(‘key1’); #value
sub hoge {
scope_container(‘key2’,‘foobar’);
}
{
my $sc2 = start_scope_container(); #
$value = scope_container(‘key1’); #value
scope_container(‘key1’,‘blahblah’);
hoge();
$value = scope_container(‘key1’); #blahblah
$value = scope_container(‘key2’); #foobar
undef $sc2;
}
$value = scope_container(‘key1’); #value
$value = scope_container(‘key2’); #undefined

61. my %DATA; #
$DATA{'key1'} = 'value1';
$value = $DATA{'key1'} #value
sub hoge {
$DATA{'key2'} = 'foobar';
}
{
local %DATA; #
$value = $DATA{'key1'} #value
$DATA{'key1'} = ‘blahblah’
hoge();
$value = $DATA{'key1'}; #blahblah
$value = $DATA{'key2'} #foobar
}
$value = $DATA{'key1'}; #value
$value = $DATA{'key2'}; #undefined

62. sub get_dbh {
my $dsn = shift
my $cache = scope_container($dsn);
reutrn $cache if $cache;
my $dbh = DBIx:Sunny->connect($dsn,$user,$pass);
scope_container($dsn, $dbh);
return $dbh;
}
while ( my $job = $queue->dequeue ) {
my $sc = start_scope_container();
my $dbh = get_dbh(); #new connection
my $dbh2 = get_dbh(); #cached
..
# disconnect
}

63. use Scope::Container;
use Scope::Container::DBI;
sub get_dbh {
Scope::Container::DBI->connect($dsn,$user,$pass,{}):
}
for my $id (1..$max) {
my $sc = start_scope_container();
get_dbh()->do(...); #new connection
get_dbh()->select_row(...); #cache
undef $sc; #
}

64. # DBI
local $Scope::Container::DBI::DBI_CLASS = “Amon2::DBI”;
my $dbh = Scope::Container::DBI->connect(
$dsn,$user,$pass,{});
# slave 1
my $dbh = Scope::Container::DBI->connect(
[$dsn1,$user,$pass,{}],
[$dsn2,$user,$pass,{}],
[$dsn3,$user,$pass,{}],
);

70. use Plack::Builder;
builder {
enable “Scope::Container”;
$app;
};
# Plack::Middleware::Scope::Container
sub call {
my ( $self, $env) = @_;
my $container = start_scope_container();
$self->app->($env);
}

73. key1 key2 key3 key4 key5 key6 key7 key8 key9
memcached1 memcached2 memcached3

74. key1 key2 key3 key4 key5 key6 key7 key8 key9
memcached1 memcached2 memcached3

75. key1 key2 key3 key4 key5 key6 key7 key8 key9
memcached1 memcached2 memcached3

76. key1 key2 key3 key4 key5 key6 key7 key8 key9
memcached1 memcached2 memcached3

77. App App
mem DB

78. App App App App
mem DB mem

79. App App App App
mem DB mem DB

81. use Cache::Memcached::IronPlate;
use Cache::Memcached::Fast;
my $memd = Cache::Memcached::IronPlate->new(
cache => Cache::Memcached::Fast->new(...),
);
$memd->get
$memd->get_multi
$memd->set
$memd->add
$memd->replace
$memd->append
$memd->prepend
$memd->incr
$memd->counter
$memd->decr
$memd->delete

82. set(‘key:dup’,val,exp) get(‘key:dup’)
IronPlate IronPlate
set key:dist:{1..3} get key:dist:{1..3}
mem1 mem2 mem3 mem1 mem2 mem3

83. set(‘key:dist’,val,exp) get(‘key:dist’)
IronPlate IronPlate
set key:dist:{1..30} get key:dist:rand(30)
mem1 mem2 mem3 mem1 mem2 mem3

84. use Cache::Isolator;
use Cache::Memcached::Fast;
my $isolator = Cache::Isolator->new(
cache => Cache::Memcached::Fast->new(...),
);
$isolator->get(key);
$isolator->set(key,val,expires);

85. set(‘key’,val,30) set(‘key’,val,30)
Isolator Isolator
set key 30 set key:earlyexp 20
mem1 mem2 mem1 mem2

86. use Cache::Isolator;
use Cache::Memcached::Fast;
my $isolator = Cache::Isolator->new(
cache => Cache::Memcached::Fast->new(...),
early_expires_ratio => 10,
expires_before => 10
);
$isolator->get(key);
$isolator->set(key,val,expires);

87. use Cache::Isolator;
use Cache::Memcached::Fast;
my $isolator = Cache::Isolator->new(
cache => Cache::Memcached::Fast->new(...),
concurrency => 3,
);
$isolator->get_or_set(key, sub {
my $dbh = get_dbh();
$dbh->select_all(heavy_sql);
}, expires);

88. DB
response memcached

89. DB
response memcached

90. DB
response memcached

91. DB
response memcached

92. DB
response memcached

93. DB
response memcached

94. DB
response memcached

95. DB
response memcached

96. DB
response memcached

97. DB
response memcached

98. DB
response memcached

99. DB
response memcached

104. use Plack::Builder;
use File::Temp;
builder {
enable "ServerStatus::Lite",
path => '/___server-status',
allow => [‘127.0.0.1’,‘192.168.0.0/16’],
scoreboard => File::Temp::tempdir(CLEANUP => 1);
$app
};

105. $ curl http://localhost:5000/___server-status
Uptime: 1318372692
BusyWorkers: 3
IdleWorkers: 27
--
pid status remote_addr host method uri protocol
1522 A 127.0.0.1 localhost:5000 GET /___server-status HTTP/1.1
1523 _ 192.168.67.3 192.168.67.4:5000 GET /foo/bar HTTP/1.0
1526 _ 192.168.67.5 192.168.67.4:5000 GET /foo/bar HTTP/1.0
...

106. use Parallel::Prefork;
use Parallel::Scoreboard;
my $sb = Parallel::Scoreboard->new(
base_dir => ‘/var/run/example_worker’ );
my $pm = Parallel::Prefork->new({...});
while ( $pm->signal_received !~ m!^(?:TERM|INT)$! ) {
$pm->start(sub{
$sb->update('.');
while(1) {
my $job = $queue->dequeue;
$sb->update('A');
#work work work
$sb->update('.');
}
});
}

107. use Parallel::Prefork;
use Parallel::Scoreboard;
my $sb = Parallel::Scoreboard->new(
base_dir => ‘/var/run/example_worker’ );
my $pm = Parallel::Prefork->new({...});
while ( $pm->signal_received !~ m!^(?:TERM|INT)$! ) {
$pm->start(sub{ idle
$sb->update('.');
while(1) {
my $job = $queue->dequeue;
$sb->update('A');
#work work work busy
$sb->update('.');
}
}); idle
}

108. # scoreboard.psgi
my $sb = Parallel::Scoreboard->new(
base_dir => ‘/var/run/example_worker’ );
sub {
my $env = shift;
my $stats = $scoreboard->read_all();
my $busy = 0;
my $idle = 0;
for my $pid ( sort { $a <=> $b } keys %$stats) {
if ( $stats->{$pid} =~ m!^A! ) {
$busy++;
} else { busy
$idle++;
}
}
return [200,['Content-Type'=>'plain/text'],
["BusyWorkers: $busynIdleWorkers: $idle"]];
};

109. #
$ plackup -p 5001 -a scoreboard.psgi
#
$ curl http://localhost:5001/___server-status
BusyWorkers: 6
IdleWorkers: 4

111. 192.188.67.2
idle
busy