6713428868

Committed 31 Oct 2023 11:06PM UTC coverage: 92.809% (+0.5%) from 92.266%

Build # 6713428868

Build Type

push

github

Committed by

jjatria

Commit Message

Bump version

Run Details

684 of 737 relevant lines covered (92.81%)

6.34 hits per line

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

51.65

/lib/OpenTelemetry/Integration/namespace.pm

package
    OpenTelemetry::Integration::namespace;
# ABSTRACT: OpenTelemetry integration for a namespace

our $VERSION = '0.011';

use strict;
use warnings;
use experimental 'signatures';

use Carp 'croak';
use Class::Inspector;
use Class::Method::Modifiers 'install_modifier';
use Feature::Compat::Defer;
use List::Util 'any';
use OpenTelemetry::Constants qw( SPAN_KIND_CLIENT SPAN_STATUS_ERROR SPAN_STATUS_OK );
use OpenTelemetry;
use Ref::Util 'is_arrayref';
use Module::Load;
use Devel::Peek;

use parent 'OpenTelemetry::Integration';

use constant {
    IS_TRACE => 0,
    IS_DEBUG => 0,
};

my ( %INSTALLED, $loaded );
sub uninstall ( $class ) {
    return unless $loaded;
    no strict 'refs';
    no warnings 'redefine';
    for my $package ( keys %INSTALLED ) {
        for my $sub ( keys %{ $INSTALLED{ $package } // {} } ) {
            delete $Class::Method::Modifiers::MODIFIER_CACHE{$package}{$sub};
            *{ $package . '::' . $sub } = delete $INSTALLED{$package}{$sub};
        }
    }
    undef $loaded;
    return;
}

my $parse_rules = sub ( $config ) {
    my ( $paths, $subroutines, $subpackages );

    if ( my @list = @{ $config->{paths} // [] } ) {
        $paths = '^(:?' . join( '|', map quotemeta, @list ) . ')';
        $paths = qr/$paths/;

        if ( IS_DEBUG ) {
            warn "Paths:\n";
            warn "- $_\n" for @list;
        }
    }

    if ( my %map = %{ $config->{subroutines} // {} } ) {
        while ( my ( $k, $v ) = each %map ) {
            @{ $subroutines->{$k} }{ @$v } = 1;
        }

        if ( IS_DEBUG ) {
            warn "Subroutines:\n";
            for my $k ( sort keys %{ $subroutines } ) {
                warn "- ${k}::$_\n" for sort keys %{ $subroutines->{$k} };
            }
        }
    }

    if ( my %map = %{ $config->{subpackages} // {} } ) {
        while ( my ( $k, $v ) = each %map ) {
            @{ $subpackages->{$k} }{ @$v } = 1;
        }

        if ( IS_DEBUG ) {
            warn "Subpackages:\n";
            for my $k ( sort keys %{ $subpackages } ) {
                warn "- ${k}:\n";
                warn "  - $_\n" for sort keys %{ $subpackages->{$k} };
            }
        }
    }

    ( paths => $paths, subroutines => $subroutines, subpackages => $subpackages )
};

sub install ( $class, %config ) {
    return if $loaded;

    my $package = $config{package};
    #     or croak 'Cannot automatically instrument OpenTelemetry without a package name';

    my %include = $parse_rules->( $config{include} );
    my %exclude = $parse_rules->( $config{exclude} );

    my $install_wrappers = sub ($package) {
        my $subs = namespace::clean->get_functions($package);

        while ( my ( $subname, $coderef ) = each %$subs ) {
            my $fullname = "${package}::$subname";

            # Skip functions we've already wrapped
            next if $INSTALLED{$package}{$subname};

            # If we are explicitly including this subroutine
            # none of the other checks matter
            if ( $include{subroutines}{$package}{$subname} ) {
                warn "Including $fullname explicitly" if IS_TRACE;
            }
            else {
                # Otherwise, perform all other additional checks
                next
                    # Skip packages we only included for some subs
                    if %{ $include{subroutines}{$package} // {} }
                    # Skip import and unimport
                    || $subname =~ /^(?:un)?import$/
                    # Skip uppercase functions
                    || uc($subname) eq $subname
                    # Skip "private" functions
                    || $subname =~ /^_/
                    # Skip subroutines we are explicitly excluding
                    || $exclude{subroutines}{$package}{$subname};

                # Skip imported functions.
                # See https://stackoverflow.com/a/3685262/807650
                if ( my $gv = Devel::Peek::CvGV($coderef) ) {
                    if ( *$gv{PACKAGE} ne $package ) {
                        warn "$package has dirty namespace ($subname)\n" if IS_TRACE;
                        next;
                    }
                }

                if ( defined prototype $coderef ) {
                    warn "Not wrapping $fullname because it has a prototype\n" if IS_TRACE;
                    next;
                }
            }

            $INSTALLED{$package}{$subname} = 1;

            install_modifier $package => around => $subname => sub {
                my ( $orig, $self, @rest ) = @_;
                OpenTelemetry->tracer_provider->tracer(
                    name    => __PACKAGE__,
                    version => $VERSION,
                )->in_span(
                    "${package}::$subname" => (
                        attributes => {
                            'code.function'  => $subname,
                            'code.namespace' => $package,
                        },
                    ),
                    sub { $self->$orig(@rest) },
                );
            };

            warn "Wrapped ${package}::$subname\n" if IS_TRACE;
        }
    };

    my $wrap = sub ($module) {
        return if
            lc $module eq $module   # pragma
            || $module =~ /^[0-9]/; # version

        my $filename = $INC{$module} or return;

        my $package = $module =~ s/\//::/gr;
        $package =~ s/\.p[ml]$//;

        return if exists $INSTALLED{$package};
        $INSTALLED{$package} = {};

        if ( my $data = $include{subpackages}{$package} ) {
            # If this package has any subpackages that we are interested
            # in wrapping, wrap those as well
            $install_wrappers->($_) for keys %$data;
        }

        # If we are specifically including any subroutine in this
        # package, then we cannot skip it wholesale
        unless ( $include{subroutines}{$package} ) {
            $package =~ /^::/ and do {
                warn "Skipping $package because it is not a package\n" if IS_TRACE;
                return;
            };

            $package =~ /^OpenTelemetry/ and do {
                warn "Skipping $package because it is ourselves\n" if IS_TRACE;
                return;
            };

            # TODO
            $package =~ /^(?:B|Exporter|Test2|Plack|XSLoader)(?:::|$)/ and do {
                warn "Skipping $package because it is not currently supported\n" if IS_TRACE;
                return;
            };

            $include{paths} && $filename !~ $include{paths} and do {
                warn "Skipping $package because it is not in include paths\n" if IS_TRACE;
                return;
            };

            $exclude{paths} && $filename =~ $exclude{paths} and do {
                warn "Skipping $package because it is in exclude paths\n" if IS_TRACE;
                return;
            };
        }

        $install_wrappers->($package);
    };

    $wrap->($_) for keys %INC;

    my $old_hook = ${^HOOK}{require__before};
    ${^HOOK}{require__before} = sub {
        my ($name) = @_;

        my $return;
        $return = $old_hook->($name) if $old_hook;

        return sub {
            $return->() if ref $return && reftype $return eq 'CODE';
            $wrap->($name);
        };
    };

    return $loaded = 1;
}

1;

1	package
2	OpenTelemetry::Integration::namespace;
3	# ABSTRACT: OpenTelemetry integration for a namespace
4
5	our $VERSION = '0.011';
6
7	use strict;	1✔
8	use warnings;	1✔
9	use experimental 'signatures';	1✔
10
11	use Carp 'croak';	1✔
12	use Class::Inspector;	1✔
13	use Class::Method::Modifiers 'install_modifier';	1✔
14	use Feature::Compat::Defer;	1✔
15	use List::Util 'any';	1✔
16	use OpenTelemetry::Constants qw( SPAN_KIND_CLIENT SPAN_STATUS_ERROR SPAN_STATUS_OK );	1✔
17	use OpenTelemetry;	1✔
18	use Ref::Util 'is_arrayref';	1✔
19	use Module::Load;	1✔
20	use Devel::Peek;	1✔
21
22	use parent 'OpenTelemetry::Integration';	1✔
23
24	use constant {
25	IS_TRACE => 0,	1✔
26	IS_DEBUG => 0,
27	};	1✔
28
29	my ( %INSTALLED, $loaded );
30	sub uninstall ( $class ) {	×
31	return unless $loaded;	×
32	no strict 'refs';	1✔
33	no warnings 'redefine';	1✔
34	for my $package ( keys %INSTALLED ) {	×
35	for my $sub ( keys %{ $INSTALLED{ $package } // {} } ) {	×
36	delete $Class::Method::Modifiers::MODIFIER_CACHE{$package}{$sub};	×
37	*{ $package . '::' . $sub } = delete $INSTALLED{$package}{$sub};	×
38	}
39	}
40	undef $loaded;	×
41	return;	×
42	}
43
44	my $parse_rules = sub ( $config ) {
45	my ( $paths, $subroutines, $subpackages );
46
47	if ( my @list = @{ $config->{paths} // [] } ) {
48	$paths = '^(:?' . join( '\|', map quotemeta, @list ) . ')';
49	$paths = qr/$paths/;
50
51	if ( IS_DEBUG ) {
52	warn "Paths:\n";
53	warn "- $_\n" for @list;
54	}
55	}
56
57	if ( my %map = %{ $config->{subroutines} // {} } ) {
58	while ( my ( $k, $v ) = each %map ) {
59	@{ $subroutines->{$k} }{ @$v } = 1;
60	}
61
62	if ( IS_DEBUG ) {
63	warn "Subroutines:\n";
64	for my $k ( sort keys %{ $subroutines } ) {
65	warn "- ${k}::$_\n" for sort keys %{ $subroutines->{$k} };
66	}
67	}
68	}
69
70	if ( my %map = %{ $config->{subpackages} // {} } ) {
71	while ( my ( $k, $v ) = each %map ) {
72	@{ $subpackages->{$k} }{ @$v } = 1;
73	}
74
75	if ( IS_DEBUG ) {
76	warn "Subpackages:\n";
77	for my $k ( sort keys %{ $subpackages } ) {
78	warn "- ${k}:\n";
79	warn " - $_\n" for sort keys %{ $subpackages->{$k} };
80	}
81	}
82	}
83
84	( paths => $paths, subroutines => $subroutines, subpackages => $subpackages )
85	};
86
87	sub install ( $class, %config ) {	1✔
88	return if $loaded;	1✔
89
90	my $package = $config{package};	1✔
91	# or croak 'Cannot automatically instrument OpenTelemetry without a package name';
92
93	my %include = $parse_rules->( $config{include} );	1✔
94	my %exclude = $parse_rules->( $config{exclude} );	1✔
95
96	my $install_wrappers = sub ($package) {	1✔
97	my $subs = namespace::clean->get_functions($package);	1✔
98
99	while ( my ( $subname, $coderef ) = each %$subs ) {	×
100	my $fullname = "${package}::$subname";	×
101
102	# Skip functions we've already wrapped
103	next if $INSTALLED{$package}{$subname};	×
104
105	# If we are explicitly including this subroutine
106	# none of the other checks matter
107	if ( $include{subroutines}{$package}{$subname} ) {	×
108	warn "Including $fullname explicitly" if IS_TRACE;	×
109	}
110	else {
111	# Otherwise, perform all other additional checks
112	next
113	# Skip packages we only included for some subs
114	if %{ $include{subroutines}{$package} // {} }	×
115	# Skip import and unimport
116	\|\| $subname =~ /^(?:un)?import$/
117	# Skip uppercase functions
118	\|\| uc($subname) eq $subname
119	# Skip "private" functions
120	\|\| $subname =~ /^_/
121	# Skip subroutines we are explicitly excluding
122	\|\| $exclude{subroutines}{$package}{$subname};	×
123
124	# Skip imported functions.
125	# See https://stackoverflow.com/a/3685262/807650
126	if ( my $gv = Devel::Peek::CvGV($coderef) ) {	×
127	if ( *$gv{PACKAGE} ne $package ) {	×
128	warn "$package has dirty namespace ($subname)\n" if IS_TRACE;	×
129	next;	×
130	}
131	}
132
133	if ( defined prototype $coderef ) {	×
134	warn "Not wrapping $fullname because it has a prototype\n" if IS_TRACE;	×
135	next;	×
136	}
137	}
138
139	$INSTALLED{$package}{$subname} = 1;	×
140
141	install_modifier $package => around => $subname => sub {
142	my ( $orig, $self, @rest ) = @_;	×
143	OpenTelemetry->tracer_provider->tracer(
144	name => __PACKAGE__,
145	version => $VERSION,
146	)->in_span(
147	"${package}::$subname" => (
148	attributes => {
149	'code.function' => $subname,
150	'code.namespace' => $package,
151	},
152	),
153	sub { $self->$orig(@rest) },	×
154	);	×
155	};	×
156
157	warn "Wrapped ${package}::$subname\n" if IS_TRACE;	×
158	}
159	};	1✔
160
161	my $wrap = sub ($module) {	4✔
162	return if
163	lc $module eq $module # pragma	4✔
164	\|\| $module =~ /^[0-9]/; # version
165
166	my $filename = $INC{$module} or return;	4✔
167
168	my $package = $module =~ s/\//::/gr;	4✔
169	$package =~ s/\.p[ml]$//;	4✔
170
171	return if exists $INSTALLED{$package};	4✔
172	$INSTALLED{$package} = {};	4✔
173
174	if ( my $data = $include{subpackages}{$package} ) {	4✔
175	# If this package has any subpackages that we are interested
176	# in wrapping, wrap those as well
177	$install_wrappers->($_) for keys %$data;	×
178	}
179
180	# If we are specifically including any subroutine in this
181	# package, then we cannot skip it wholesale
182	unless ( $include{subroutines}{$package} ) {	4✔
183	$package =~ /^::/ and do {	4✔
184	warn "Skipping $package because it is not a package\n" if IS_TRACE;	×
185	return;	×
186	};
187
188	$package =~ /^OpenTelemetry/ and do {	4✔
189	warn "Skipping $package because it is ourselves\n" if IS_TRACE;	1✔
190	return;	1✔
191	};
192
193	# TODO
194	$package =~ /^(?:B\|Exporter\|Test2\|Plack\|XSLoader)(?:::\|$)/ and do {	3✔
195	warn "Skipping $package because it is not currently supported\n" if IS_TRACE;	2✔
196	return;	2✔
197	};
198
199	$include{paths} && $filename !~ $include{paths} and do {	1✔
200	warn "Skipping $package because it is not in include paths\n" if IS_TRACE;	×
201	return;	×
202	};
203
204	$exclude{paths} && $filename =~ $exclude{paths} and do {	1✔
205	warn "Skipping $package because it is in exclude paths\n" if IS_TRACE;	×
206	return;	×
207	};
208	}
209
210	$install_wrappers->($package);	1✔
211	};	1✔
212
213	$wrap->($_) for keys %INC;	1✔
214
215	my $old_hook = ${^HOOK}{require__before};	×
216	${^HOOK}{require__before} = sub {
217	my ($name) = @_;	×
218
219	my $return;	×
220	$return = $old_hook->($name) if $old_hook;	×
221
222	return sub {
223	$return->() if ref $return && reftype $return eq 'CODE';	×
224	$wrap->($name);	×
225	};	×
226	};	×
227
228	return $loaded = 1;	×
229	}
230
231	1;

jjatria / perl-opentelemetry / 6713428868

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