File Coverage

blib/lib/Sentry/Hub/Scope.pm

Criterion	Covered	Total	%
statement	96	155	61.9
branch	11	22	50.0
condition	8	14	57.1
subroutine	18	29	62.0
pod	0	21	0.0
total	133	241	55.1

use Mojo::Base -base, -signatures;

use Clone qw();
use Mojo::Util 'dumper';
use Sentry::Severity;
use Sentry::Tracing::Span;
use Sentry::Util 'merge';
use Time::HiRes;

has breadcrumbs            => sub { [] };
has contexts               => sub { {} };
has error_event_processors => sub { [] };
has event_processors       => sub { [] };
has extra                  => sub { {} };
has fingerprint            => sub { [] };
has level                  => Sentry::Severity->Info;
has span                   => undef;
has tags                   => sub { {} };
has transaction_name       => undef;
has user                   => undef;

  $self->span($span);
  return $self;
}

  $self->user($user);
}

  $self->extra->{$name} = $value;
}

  $self->extra = { %{ $self->extra }, %{$extras} };
}

  $self->tags->{$key} = $value;
}

  $self->tags({ $self->tags->%*, $tags->%* });
}

  if (not defined $context) {
    delete $self->contexts->{$key};
  } else {
    $self->contexts->{$key} = $context;
  }

  # $self->_notify_scope_listeners();

  return $self;
}

  $self->level($level);
}

  $self->transaction_name($name);
  return $self;
}

  return $self->span;
}

  $self->fingerprint($fingerprint);
}

  push $self->event_processors->@*, $event_processor;
}

  push $self->error_event_processors->@*, $error_event_processor;
}


  # Resets a scope to default values while keeping all registered event
  # processors. This does not affect either child or parent scopes
}

  $breadcrumb->{timestamp} //= time;
  push @{ $self->breadcrumbs }, $breadcrumb;
}

  $self->breadcrumbs([]);
}

# Applies fingerprint from the scope to the event if there's one,
# uses message if there's one instead or get rid of empty fingerprint
  $event->{fingerprint} //= [];

  $event->{fingerprint} = [$event->{fingerprint}]
    if ref($event->{fingerprint} ne 'ARRAY');

  $event->{fingerprint} = [$event->{fingerprint}->@*, $self->fingerprint->@*];

  delete $event->{fingerprint} unless scalar $event->{fingerprint}->@*;
}

# Applies the scope data to the given event object. This also applies the event
# processors stored in the scope internally. Some implementations might want to
# set a max breadcrumbs count here.
  merge($event, $self, 'extra')    if $self->extra;
  merge($event, $self, 'tags')     if $self->tags;
  merge($event, $self, 'user')     if $self->user;
  merge($event, $self, 'contexts') if $self->contexts;

  $event->{level} //= $self->level                if $self->level;
  $event->{transaction} = $self->transaction_name if $self->transaction_name;

  if ($self->span) {
    $event->{request} = $self->span->request;

    $event->{contexts} = {
      trace => $self->span->get_trace_context(),
      ($event->{contexts} // {})->%*
    };

    if (my $transaction_name = $self->span->transaction->name) {
      $event->{tags}
        = { transaction => $transaction_name, ($event->{tags} // {})->%* };
    }
  }

  $self->_apply_fingerprint($event);

  $event->{breadcrumbs}
    = [($event->{breadcrumbs} // [])->@*, $self->breadcrumbs->@*];

  my @event_processors
    = (get_global_event_processors()->@*, $self->event_processors->@*);

  foreach my $processor (@event_processors) {
    $event = $processor->($event, $hint);
  }

  return $event;
}

  Clone::clone($self);
}

  $self->$_($fields->{$_}) for keys $fields->%*;
}

  state $processors = [];
  return $processors;
}

  push get_global_event_processors()->@*, $processor;
}

1;