6553776671

Committed 17 Oct 2023 10:57PM UTC coverage: 73.52% (-18.9%) from 92.443%

Build # 6553776671

Build Type

push

github

Committed by

jjatria

Commit Message

Add experimental support for testing metrics

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

472 of 642 relevant lines covered (73.52%)

4.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

53.57

/lib/OpenTelemetry.pm

package OpenTelemetry;
# ABSTRACT: A Perl implementation of the OpenTelemetry standard

use strict;
use warnings;
use experimental qw( isa signatures );

our $VERSION = '0.001';

use Mutex;
use OpenTelemetry::Common;
use OpenTelemetry::Context;
use OpenTelemetry::Propagator::None;
use OpenTelemetry::Trace::TracerProvider;
use OpenTelemetry::X;
use Scalar::Util 'refaddr';
use Ref::Util 'is_coderef';
use Sentinel;

use Log::Any;

use Exporter::Shiny qw(
    otel_context_with_span
    otel_current_context
    otel_error_handler
    otel_handle_error
    otel_logger
    otel_propagator
    otel_span_from_context
    otel_tracer_provider
);

my $logger = Log::Any->get_logger( category => 'OpenTelemetry' );
sub logger { $logger }
sub _generate_otel_logger { \&logger }

{
    my $lock = Mutex->new;
    my $instance = OpenTelemetry::Trace::TracerProvider->new;

    my $set = sub ( $new ) {
        die OpenTelemetry::X->create(
            Invalid => 'Global tracer provider must be a subclass of OpenTelemetry::Trace::TracerProvider, got instead ' . ( ref $new || 'a plain scalar' ),
        ) unless $new isa OpenTelemetry::Trace::TracerProvider;

        $lock->enter( sub { $instance = $new });
    };

    sub _generate_otel_tracer_provider {
        my $x = sub :lvalue { sentinel get => sub { $instance }, set => $set };
    }

    sub tracer_provider :lvalue { sentinel get => sub { $instance }, set => $set }
}

{
    my $lock = Mutex->new;
    my $instance = OpenTelemetry::Propagator::None->new;

    my $set = sub ( $new ) {
        die OpenTelemetry::X->create(
            Invalid => 'Global propagator must implement the OpenTelemetry::Propagator role, got instead ' . ( ref $new || 'a plain scalar' ),
        ) unless $new && $new->DOES('OpenTelemetry::Propagator');

        $lock->enter( sub { $instance = $new });
    };

    sub _generate_otel_propagator {
        my $x = sub :lvalue { sentinel get => sub { $instance }, set => $set };
    }

    sub propagator :lvalue { sentinel get => sub { $instance }, set => $set }
}

sub _generate_otel_current_context {
    my $sub = sub :lvalue { OpenTelemetry::Context->current };
}

sub _generate_otel_context_with_span {
    sub { OpenTelemetry::Trace->context_with_span(@_) };
}

sub _generate_otel_span_from_context {
    sub { OpenTelemetry::Trace->span_from_context(@_) };
}

{
    my $lock = Mutex->new;
    my $instance = sub (%args) {
        my $error = join ' - ', grep defined,
            @args{qw( message exception )};

        $logger->error("OpenTelemetry error: $error");
    };

    my $set = sub ( $new ) {
        die OpenTelemetry::X->create(
            Invalid => 'Global error handler must be a code reference, got instead ' . ( ref $new || 'a plain scalar' ),
        ) unless is_coderef $new;

        $lock->enter( sub { $instance = $new });
    };

    sub _generate_otel_error_handler {
        my $x = sub :lvalue { sentinel get => sub { $instance }, set => $set };
    }

    sub error_handler :lvalue { sentinel get => sub { $instance }, set => $set }

    sub _generate_otel_handle_error { sub {  $instance->(@_); return } }
    sub                handle_error { shift; $instance->(@_); return   }
}

1;

1	package OpenTelemetry;
2	# ABSTRACT: A Perl implementation of the OpenTelemetry standard
3
4	use strict;	5✔
5	use warnings;	5✔
6	use experimental qw( isa signatures );	5✔
7
8	our $VERSION = '0.001';
9
10	use Mutex;	5✔
11	use OpenTelemetry::Common;	5✔
12	use OpenTelemetry::Context;	5✔
13	use OpenTelemetry::Propagator::None;	5✔
14	use OpenTelemetry::Trace::TracerProvider;	5✔
15	use OpenTelemetry::X;	5✔
16	use Scalar::Util 'refaddr';	5✔
17	use Ref::Util 'is_coderef';	5✔
18	use Sentinel;	5✔
19
20	use Log::Any;	5✔
21
22	use Exporter::Shiny qw(	5✔
23	otel_context_with_span
24	otel_current_context
25	otel_error_handler
26	otel_handle_error
27	otel_logger
28	otel_propagator
29	otel_span_from_context
30	otel_tracer_provider
31	);	5✔
32
33	my $logger = Log::Any->get_logger( category => 'OpenTelemetry' );
34	sub logger { $logger }	×
35	sub _generate_otel_logger { \&logger }	×
36
37	{
38	my $lock = Mutex->new;
39	my $instance = OpenTelemetry::Trace::TracerProvider->new;
40
41	my $set = sub ( $new ) {
42	die OpenTelemetry::X->create(
43	Invalid => 'Global tracer provider must be a subclass of OpenTelemetry::Trace::TracerProvider, got instead ' . ( ref $new \|\| 'a plain scalar' ),
44	) unless $new isa OpenTelemetry::Trace::TracerProvider;
45
46	$lock->enter( sub { $instance = $new });
47	};
48
49	sub _generate_otel_tracer_provider {
50	my $x = sub :lvalue { sentinel get => sub { $instance }, set => $set };	×
51	}
52
53	sub tracer_provider :lvalue { sentinel get => sub { $instance }, set => $set }	×
54	}
55
56	{
57	my $lock = Mutex->new;
58	my $instance = OpenTelemetry::Propagator::None->new;
59
60	my $set = sub ( $new ) {
61	die OpenTelemetry::X->create(
62	Invalid => 'Global propagator must implement the OpenTelemetry::Propagator role, got instead ' . ( ref $new \|\| 'a plain scalar' ),
63	) unless $new && $new->DOES('OpenTelemetry::Propagator');
64
65	$lock->enter( sub { $instance = $new });
66	};
67
68	sub _generate_otel_propagator {
69	my $x = sub :lvalue { sentinel get => sub { $instance }, set => $set };	×
70	}
71
72	sub propagator :lvalue { sentinel get => sub { $instance }, set => $set }	×
73	}
74
75	sub _generate_otel_current_context {
76	my $sub = sub :lvalue { OpenTelemetry::Context->current };	×
77	}
78
79	sub _generate_otel_context_with_span {
80	sub { OpenTelemetry::Trace->context_with_span(@_) };	×
81	}
82
83	sub _generate_otel_span_from_context {
84	sub { OpenTelemetry::Trace->span_from_context(@_) };	×
85	}
86
87	{
88	my $lock = Mutex->new;
89	my $instance = sub (%args) {
90	my $error = join ' - ', grep defined,
91	@args{qw( message exception )};
92
93	$logger->error("OpenTelemetry error: $error");
94	};
95
96	my $set = sub ( $new ) {
97	die OpenTelemetry::X->create(
98	Invalid => 'Global error handler must be a code reference, got instead ' . ( ref $new \|\| 'a plain scalar' ),
99	) unless is_coderef $new;
100
101	$lock->enter( sub { $instance = $new });
102	};
103
104	sub _generate_otel_error_handler {
105	my $x = sub :lvalue { sentinel get => sub { $instance }, set => $set };	×
106	}
107
108	sub error_handler :lvalue { sentinel get => sub { $instance }, set => $set }	×
109
110	sub _generate_otel_handle_error { sub { $instance->(@_); return } }	×
111	sub handle_error { shift; $instance->(@_); return }	×
112	}
113
114	1;

jjatria / perl-opentelemetry / 6553776671

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous