package Sys::Trace;
use strict;
use Sys::Trace::Results;

our $VERSION = "0.03";

=head1 NAME

Sys::Trace - Interface to system call tracing interfaces


  use Sys::Trace;

  my $trace = Sys::Trace->new(exec => [qw(ls foo)]);

  $trace->start; # Returns a PID which you can watch
  $trace->wait;  # Alternatively call this to wait on the PID

  my $result = $trace->results; # Returns a Sys::Trace::Results object

  use Cwd;
  print $result->files(getcwd . "/"); # Should show an attempt to look at "foo"
                                      # in the current directory (i.e. "ls
                                      # foo", above)


Provides a way to programmatically run or trace a program and see the system
calls it makes.

This can be useful during testing as a way to ensure a particular file is
actually opened, or another hard to test interaction actually occurs.

Currently supported tracing mechanisms are ktrace, strace and truss.

=head1 METHODS


our @INTERFACES = qw(

our @ISA;

my $interface_class = "";

=head2 new(%args)

Keys in C<%args> can be:

=over 4

=item *

B<exec>: Program and arguments to execute

=item *

B<pid>: PID of program to trace

=item *

B<follow_forks>: Follow child processes too (default is 1, set to 0 to disable)


Only one of exec or pid must be provided.


sub new {
  my($class, %args) = @_;

  if(!$interface_class) {
    for my $interface(@INTERFACES) {
      my $file = $interface;
      $file  =~ s{::}{/}g;
      $file .= ".pm";
      eval { require $file } or next;

      if($interface->usable) {
        $interface_class = $interface;
        @ISA = $interface_class;

  if(!$interface_class) {
    require Carp;
    Carp::croak("No interface for system call tracing is available on this platform");

  # Default to following forks
  $args{follow_forks} = 1 unless exists $args{follow_forks};

  return $class->SUPER::new(%args);

=head2 start

Start running the trace.


sub start {
  my($self) = @_;

  if(!defined $self->pid(fork)) {
    die "Unable to fork: $!";

  return $self->pid if $self->pid; # parent

=head2 wait

Wait for the trace to finish


sub wait {
  my($self) = @_;

  $? if waitpid $self->pid, 0;

=head2 results

Return a L<Sys::Trace::Results> object populated with the results of the trace.


sub results {
  my($self) = @_;

  return Sys::Trace::Results->new($self);



=head1 BUGS

This does what I wanted, it is probably woefully incomplete in places.

See L<>.

=head1 LICENSE

This program is free software. It comes without any warranty, to the extent
permitted by applicable law. You can redistribute it and/or modify it under the
terms of the Do What The Fuck You Want To Public License, Version 2, as
published by Sam Hocevar. See or
L<Software::License::WTFPL_2> for more details.

=head1 AUTHOR

David Leadbeater E<lt>L<>E<gt>, 2010