►
From YouTube: 2023-03-09 meeting
Description
cncf-opentelemetry@cncf.io's Personal Meeting Room
B
C
C
E
C
I
just
wanted
to
understand
and
start
not
really
dig
in
where
I
always.
You
comment
about.
C
I
think
I
added
this
pair
does
not
attempt
to
address
issues
where
agent
code
could
allow
user
code
to
circumvent
security
manager.
So
is
this:
could
they
already
use
agent
code
to
circumvent
security
manager,
or
this
is
something
new
that
could
be
possible
now
that
we're
adding
these
checks
or
giving
ourselves
permissions.
G
Currently,
I
think
the
agent
doesn't
start
when
you
have
security
manager
enabled
or
or
maybe
it
does,
a
few
of
them.
If
you
figure
out
the
appropriate
set
of
permissions,
but
probably
currently
it
would
need
to
include
access
to
reflection
or
something
like
that.
That
would
anyway
allow
you
to
do
nasty
things
to
the
security
manager.
C
Right
so
is:
are
you
suggesting
then,
that
since
it
wasn't
working
before
and
since
this
at
least
makes
something
work.
G
G
If
that
initialization
path
starts
from
the
user
code,
then
then
it
currently
fails.
Although
I
I
guess
we
could
like
run
everything
that
comes
into
the
agent
with
two
privileged
to
work
around
it.
C
Yeah
that
this
just
makes
me
nervous,
I
mean
not
kind
of
rather
I'd,
almost
rather
not
support
security
managers
than
to
potentially
be
giving
a
adding
a
whole
security
hole
win
through
security
managers.
G
Like
if
you're
meaning
about
like
to
do
privileged,
then
it
actually
usually
it
doesn't
allow
anybody
to
do
anything
because
you
watch
it
basically.
D
G
Says
that
when
you're
calling
two
privilege,
you
say
that
I
have
downloaded
all
the
checks
and
the
call
that's
going
to
happen.
It
looks
okay
to
me
like
hold
the
security
manager
works.
Is
it
basically
takes
all
the
colors
of
the
methods
and
checks
that
all
the
callers
have
the
privilege
to
do
something?
But
when
you
call
the
two
privileged,
you
basically
say
that
don't
check
my
callers.
C
E
C
G
G
But
I
think
it's
a.
This
could
be
like
more
like
a
prototype
or
like
if
there
is
actually
somebody
who
wants
to
use
the
security
manager
with
agent,
then
I
would
expect
them
to
like
complain
to
us
and
give
us
more
context.
So
we
could
figure
out
like
how
to
solve
those
issues.
G
And
there
was
one
issue
from
somebody
from
IBM
but
I
think
yeah.
It
wasn't
an
agent
issue
that
was
issue
with
the
instrumentation
library,
and
this
pull
request
doesn't
affect
that
one.
E
C
So
Lori
we're
basically
in
terms
of
security,
potentially
security
issues.
We
have
to
look
at
what
we're
wrapping
in
due
privileged
and
make
sure
it's
not
something.
That
would
because,
like
that,
one
kind
of
scared
me
that
you
could
somehow
create
new
classes,
Define
classes.
G
G
C
So
which
yeah
so,
which?
How
would
I
tell
in
here
which
things
oh,
is
this
the
only
privileged
do
privilege
that
we're
running.
G
H
C
G
G
Because
extensions
are
part
of
the
agent,
they
have
the
Privileges
to
do
whatever
they
want.
H
C
Right
already
already
yeah,
okay
yeah,
so
it's
not
a
change.
Yeah
extensions
are
trusted,
it's
more
about,
say,
you're
running
some
multi-tenant
app
and
you're,
allowing
people
to
run
some
code
put
add
their
own
code
into
their.
You
know
tenancy
piece
and
you
have
a
security
manager
in
place
to
you
know
kind
of
sandbox
that,
and
so
you
know
that's
to
prevent
people
from
jumping
over
walls.
G
I
think
nowadays,
maybe
like
most
of
the
security
managers.
They
have
been
inherited
from
somewhere
over
the
guys
who
devised
them
have
already
left
and
nobody
knows
and
what
they
are
exceptions.
F
C
What
if
we
make
an
opt-in
feature,
and
then
we
can,
you
know,
add
docs
with
kind
of
that
warning.
C
G
Maybe
we
have
to
like
phrase
forecast
for
them,
something
like
that.
We
haven't
audited
it
and
that's
why
we
don't
take
any
responsibility.
C
Yeah,
because
my
My
worry
is
just
that
somebody,
you
know,
grabs
the
Java
agent
off
the
shelf.
You
know
isn't
aware
of
what
their
app
is
doing,
isn't
aware
of
what
the
Java
agent
is
doing:
slap
the
job
agent
onto
their
legacy.
App
and
now
you
know,
pretend
there's
a
potential
security,
vulnerability.
A
A
C
Okay,
I'm
I'm
good,
with
either
of
those
approaches,
either
opt-in
and
document
or
if
we
want
to
you,
know,
go
through
to
audit
it
a
little
bit
more
carefully.
G
I
think
that
the
there
might
be
one
more
thing
that
we
have
to
still
do
it's
it's
like.
We
might
need
to
fix
it
like
if
the
user
code
calls
into
the
agent
then
so
it
wouldn't
break
I
I
tried
like
great
the
really
really
small
app
and
it
it
seemed
that
it
worked.
I
probably
also
need
to
add
a
test
to
this
pull
request.
G
C
H
F
G
So
there
was
one
problem
with
this
system:
taking
the
system
properly
requires
privileges
to
get
to
the
point,
wherever
you
can
actually
check
the
system
properly,
you
have
to
do
most
of
stuff.
That's
done
there
already.
G
C
E
Yeah
so
basically,
the
last
time
I
came
to
the
call
we
discussed.
The
least
Dramatics
to
the
I
mean
going
to
be
stabilized
for
the
ATP
ones.
Why
is
the
request?
The
other
one's
response
and
then
I
went
back
to
the
micro
profile
community
and
the
metrics
yeah
team
and
I?
Think
of
the
HTTP
ones,
looks
good
and
also
we
kind
of
work
hard
to
focus
on
the
gvm
metrics
as
well.
I'm
wondering
I
mean
how
far
are
we
at
for
step
stabilizing
the
gvm
metrics.
C
At
the
same
time,
I
mean
so
there's
currently,
no,
the
is
in
terms
of
overall
open,
Telemetry
priorities,
the
stabilization
semantic
convention,
stabilization
priorities
are
HTTP
messaging
and
database,
but
I
mean
we
potentially
as
the
Java
Community
could
push
and
try
to
influence
on
some
or
all
of
these.
C
We
would
can
you
give
us
sort
of
a
big
picture
from
microprofile
how
how
you're,
integrating
with
open
Telemetry
or
the
semantic
conventions,
because
that
would
give
us
some.
You
know
something
to
go
back
to
you
know
to
push
on
the
spec
Community
the
open,
the
the
broader
community
and
say
hey
this
is
you
know
this
is
a
really
important
integration
ecosystem
that
we're
trying
to
support.
E
Yeah,
so
a
micro
profile
like
a
community,
we
want
to
take
a
basic.
Please
increase
the
open,
Telemetry
tracing.
We
already
done
that
and
also
embrace
the
open,
Telemetry
Matrix.
Basically,
the
we
just
expose
the
API
The
Matrix,
apis
and
plus
the
Matrix.
This
Matrix
name
metric
names
and
we
made
a
build
on
top
of
it
for
usability
and
integrate
better
with
the
Decatur,
like
standards
and
SD
card
and
microprofile
standard,
so
but
I
mean
basically
improve
the
usability
for
Java
developers,
developing
Cloud
native
applications.
This
is
with
that
also.
E
We
will
like,
for
example,
profile
for
tolerance,
also
integrate
with,
like
previously
the
micro
profile
metrics.
Now
it's
kind
of
we
need
to
integrate
with
the
open,
Telemetry
Matrix.
This
is
basically
this
like.
We
would
like
to
have
like
a
stabled
symmetrical
conventions
for
some
metrics,
especially
like
in
the
microprofile
group.
E
We
have
kind
of
some
different
style
with
the
metrics
like
a
base
Matrix
vendor
Matrix
and
application
Matrix
for
based
metrics,
basically
auto
box,
The
Matrix,
the
audio
DVM
Matrix
we
would
like
to
see
like
a
customer
is
one
is
when
they
got
it,
enabled
micro
profile,
basically
open,
Telemetry
Matrix.
They
will
be
able
to
see
all
the
GBM
metrics.
So
if
this
will
keep
on
changing
the
name
aspect
and
keep
on
changing
so
that
between
the
releases
is
quite
difficult
to
create
a
queries,
for
example,
to
clearly
any
kind
of
Matrix.
C
Great
thanks
one
question
about
the
open,
Telemetry
metrics.
So
did
you
end
up
all
right?
Do
you
have
Micro
profile
metrics
API
as
a
an
abstraction,
or
are
you
exposing
open
Telemetry?
Are
you
looking
at
exposing
open,
Telemetry,
metrics
API
directly.
E
We
are
looking
at
the
exposing
Hotel
Matrix
directly.
So
basically,
once
we
get
this
piece
of
job
done
and
we
are
kind
of
probably
more
favor
Hotel
Matrix
over
micro
profile
metrics,
so
it's
yeah
and
then
people
can
use
the
micro
profile
metrics
if
they
choose
choose
to.
It
would
like
to
like,
basically
not
to
know
to
evolve
a
lot
more
there.
We
want
to
integrate
the
better
with
Hotel
metrics
to
take
some
advantage
of
the
basically
a
language
agnostic
kind
of
behaviors
in
the
hotel,
Matrix
I.
E
C
Yeah,
that's
what
I
was
thinking
also.
Is
this
by
the
way,
are
you
working
with
Ed,
Burns,
yeah.
E
C
Because
he
picked
me
he's
at
Microsoft.
He
pinged
me
about
this
exact
topic
recently.
E
Sounds
familiar
yeah
yeah!
That's
right!
We
work
together,
yeah
on
these
open,
Telemetry
macro
profile,
telemetries
back
so
yeah.
C
Okay,
yeah,
so
why
don't
we
take
I
can
take
this
as
an
action
item
I'm
on
vacation
for
the
next
two
weeks,
but
when
I'm
back
I
can
start
sort
of
feeling
this
out
pushing
on
this.
E
Is
this
is
a
our
radio
supply?
The
question
I
I
think
he's
the
quest,
ambitious.
We
say
and
I
think
we
would
need
to
start
like
working
like
on
this
ASAP.
Hopefully,
I
think
if
we
couldn't
get
it
released
in
June's
time,
sometimes
like
in
the
3Q
I
think
we
should
be
able
to.
We
should
get
hit,
but
anyway,
at
the
moment
is
too
cute,
but
I
don't
know
whether
we
can
achieve
anything
or
achieve
this
better
to
kill
because
they
are
the
kind
of
other
dependencies
and
Etc.
E
Yeah
yeah,
that
would
be
a
major
version.
Micro
profile,
I'll,
be
micro
profile.
Seven
yeah,
but
I
think
that
looks
like
the
scope
of
to
adopt
a
matrix
is
a
is
quite
big,
so
I'm
not
sure
we
could
could
have
finished
everything
or
by
like
a
2q,
so
very
yeah.
It's
likely
to
push
further,
but
at
the
moment
we
are
kind
of
ambitiously
targeted
for
2q,
but
at
least
I
started
working
on
it.
C
C
Yeah
I
I
mean
I
I,
I
love
that
I
think
that
is
really.
You
know
what
we
want
to
see
and
we
want
to
support
that
and
I
think
it
may
be
possible
given,
like
you
said
it's
just
Java.
If
it
was
cross-language,
then
I'd
be
like
no.
It's
not.
You
know
it's
gonna
be
a
while
still,
but
for
these
I
think
there's
a
there's,
a
there's,
a
chance
hope.
I
One
little
note
is
that.net
already
has
published
stable
semantic
conventions
for
its
runtime.
I
They
don't
they're,
not
included
in
the
semantic
conventions
anywhere,
because
you
know
the.net
runtime
is
managed
internally,
but
the
the
artifact
is
stable
and
the
instrumentation
is
stable.
C
Is
there
any
feedback?
Does
the
micro
profile
team
have
any
feedback
on
the
existing
metrics
I
mean?
Do
they
have
any?
You
know,
because
that's
part
of
what
we
would
look
for
as
far
as
stable
moving
to
stability
is
getting.
You
know
some
broader
feedback
on
hey
these
look
great.
This
is
you
know
or
hey.
You
know
we
would
recommend
making
these
changes
kind
of
a
thing.
Oh.
F
E
That
I
think
yeah
I
think
I
I
will
have
a
chat
with
him
again,
so
we
went
through
basically
easy,
very
interesting
in
the
DVM
metrics.
So
it's
I
will
ask
him
to
provide
feedback
to
see
because
the
in
like
IBM,
we
provide
quite
a
lot
of
gvm
metrics.
It's
the
IBM
style,
some
TVM
metrics.
So
it's
yeah
we'll
get
back
to
you.
C
I
Yeah,
try
ask
if
we,
if,
if
we
could
put
a
schedule
in
place,
it's
like
you
know,
convinced
the
the
specification
folks
that
you
know
this
is
a
priority
and
and
basically
bless
like
the
effort
to
make
these
stable.
Then
we
could
put
a
data
on
the
calendar
and
us
that
vendors
could
go
and
solicit
internal
feedback,
which
I
know
a
New
Relic,
where
we
we
almost
exclusively
use
Java
internally.
I
So
there's
a
lot
of
users
that
I'm
sure
would
have
good
feedback,
and
if
we
could
have
a
date
in
mind,
then
that
would
be
a
very
I
guess.
Specific
call
for
action.
C
Yeah,
you
know
what
I'll
do
when
I'm
back
as
I
will
open
a
project
tracking
I'd
make
it
an
official
project
to,
and
then
we
can
we'll
get.
You
know
people
involved
and
Emily
what
we've
done
with
HTTP
semantic
conventions.
Is
we
kind
of
form
a
working
group
and
we
meet
just
as
that
working
group
fairly
frequently
to
hash
out
everything?
C
I
C
All
right-
oh
I,
just
threw
this
on
here.
Mateus.
C
I
didn't
know
if
you
wanted
to
I,
didn't,
have
a
chance
to
look
at
anything
to
well.
I
didn't
have
a
chance
to
look
at
anything
other
than
this
comment.
A
Yeah
I
mean
this
comments
pretty
much
some
of
all
the
new
changes
I
added
today,
so
I
started
by
adding
the
wrapper
span
that
we've
been
talking
about
in
the
HTTP
6
and
I,
didn't
exactly
like,
like
how
it
looks
like
so.
I
also
thought
about
the
other
way,
which
is
like
creating
specifically
a
Spam
when,
when
there
was
no
like
in
no
attempt
to
send
the
HTTP
request
was
made.
A
So
if
we
are
pretty
much
certain
that
it
failed
somewhere
on
the
connection
phase
or
like
the
another
like
pre-sending,
then
we
can
just
create
a
hcd
span
like
and
some
kind
of
span,
and
just
you
know
just
so
it
is
present
in
any
way
and
there
there
are
errors
on
it.
So
yeah
the
other
I
mean
the
second
option
that
I
proposed
here.
I
I
think
we
probably
don't
need
to
add
any
new
spec.
A
Maybe
we
can
like
relax
what
we
already
have
a
little
bit,
so
this
situation
is
isn't
explicitly
forbidden,
so
it's
like
by
extension,
it's
it's
allowed,
but
until
we
decide
what
to
do
with
this,
like
lower
level
connection
thing
is,
then
we
could
just
implement
it
like
that
in
all
instrumentations
that
actually
instrument
the
low
level
stuff.
A
A
So
if
you
have
a
chance,
please
take
a
look
at
it.
I
mean
it
is
a
little
bit
hacky,
but
it's
not
not
too
terrible.
I
think,
and
this
could
probably
help
us
move
forward
with
the
spec
thing
about
Connections,
which
is
kind
of
blocked
right
now.
I
think
nobody
really
wants
to
like
commit
to
anything
further
than
just
just
HTTP
span.
C
Yeah
yeah
I,
don't
think
we
will
commit
to
defining
an
encompassing
span.
I
think
instrumentation
is
always
free
to.
E
A
It's
it's
not
really.
The
best
solution,
probably.
A
I'll,
try
and
Eddie
next
I'm
guessing
that
I
will
fail
to
add
this
pan
in
Neti,
but
well
we'll
see.
C
Yeah
and
that's
okay,
I
wonder:
if
do
you
think
you,
like
I,
don't
know
how
much
higher
level
reactor
Neti
reactor
is?
D
A
I'll
try
reactor
too
I
mean
I,
haven't
written
down
on
my
to-do
list.
I
didn't
even
know
like
how
reactor
handles
retrace
if
it's,
if
it's
like,
being
hidden
somewhere
internally
or
if
it
exposes
like
we
tries
to
do
the
user.
A
D
G
Basically,
the
kotlin
instrumentation
works
so
that
when
the
core
routing
is
suspended,
then
we
save
the
context.
But
then
we,
then
we
close
the
scope
that
was
opened
for
it.
But
the
problem
is
that
if,
during
the
livestock
of
their
horror
team,
another
scope
was
opened,
then
colleagues
close
doesn't
do
anything,
because
it
figures
out
that
that
the
current
scope
isn't
the
same
scope.
That
was
active
when,
when
the
original
scope
was
opened.
D
I
That's
one:
that's
what
I
was
gonna
ask.
Does
it
indicate
that
something
has
gone
wrong
if
the
if
the
scope
is
left
unclosed
that
that
gets
replaced
in
thread
local.
G
I
think
that
core
routines
it
doesn't
indicate
because
when
you
write
the
code,
it
will
still
like
make
sense.
The
part
that
suspends
is
actually
like
in
the
middle
somewhere.
C
G
C
G
Well,
it
looks
the
warning
but
like
from
the
perspective
of
the
strict
context,
checking
like
nothing
wrong
was
done.
I
C
F
I
F
G
C
H
C
F
I
D
G
I
think
it's
if
you're
doing
a
double
close
on
the
scope,
then
the
second
flows
would
get
ignored.
I
D
I
G
C
Yeah
I
mean
I
I
kind
of
wish
that
I
would
look
to
see.
Maybe
our
Tech,
like
our
all
of
our
integration
tests,
fail
if
this
happens
at
least
so
we
can
see
if
that's
a
more
General
problem.
I
Just
like
build
it
with
with
the
relaxingness
and
then
see
if
the
integration
tests
fail.
G
C
C
Maybe
maybe
closed
just
because
I,
like
I,
mean
we,
we
had
a
customer
recently
who
was
doing
their
own
grpc
context
stuff,
and
they
were
not.
They
actually
were
never
closing
it.
So
it
wasn't
the
same
problem,
but
it
was
causing
problems
because
of
our
grpc
context.
Bridge
and
so
I
do
like
this
strict,
more
strict
interpretation
of
the
thread:
local
storage,
by
default,
at
least.
I
I
could
close
any
method
like
close.
Whatever
scope
is
in
thread,
local.
G
You
know
closing
like
I
think
if
you
closed
the
scope,
while
misted
Scopes
were
open,
then
they
automatically
closed
all
of
them
right.
C
So
that
would
be
like
if
you
had
this
one,
you
had
scope
a
and
then
nestoscope
B
and
then,
if
you
tried
to
close
scope
a
while
scope,
B
was
open,
it
would
just
collapse
and
close
them.
G
C
G
C
Is
there
no
better,
is
there
nothing
in
the
so
is
this
particular
is
Zio
I
thought
Gio
was
Scala.
Is.
G
C
A
G
G
G
Also
be
like
that,
that
might
not
be
wrong
with
the
core
routines,
always.
G
C
Sir
yeah
sir
I
mean
in
that
sense
we
have.
We
have
the
context
right.
We
make
the
scope,
we
make
it
current,
we
get
a
scope,
we
close
it
and
that's
where
I
feel
like
the
hooks.
The
kotlin
hooks
seemed
pretty
good
as
far
as
we
know
when
it's
suspended
and
we
can
close
that
scope
and
then,
when
it's
resumed,
we
can
just
make
the
same
context
current
again.
Actually.
G
Like
but
the
quality
starts,
your
you
have
some
context,
but
when
it
suspends,
you
have
a
different
context
where
you
have
already
like
domestic
scope.
Is
there
also.
C
Okay,
my
brain
is
broken
and
it's
not
going
to
get
fixed
in
the
next
six
minutes.
Yeah,
that's
hard
stuff.
C
Let's
hit
the
last
couple
of
topics.
Jack.
I
Oh
I,
don't
have
much
to
talk
about
here.
I
just
wanted
to
say
that
I'm
planning
on
doing
the
release
tomorrow,
notably
1.19.0
of
the
semantic
inventions,
was
released,
but
there's
a
lot
of
churn
in
those
and
the
build
tools
that
provides
the
code
generation
feature.
It
doesn't
work
with
them
with
those,
and
so
there's
there's
some
folks
that
are
working
on
fixing
that
back
up
and
providing
new
Solutions.
So
those
changes
won't
be
in
this
release,
as
we'll
have
to
get
picked
up
in
in
April's
release.
I
That's
all
I
have
to
say
about
that.
If
anyone
else
has
things
that
you
think
should
be
addressed
last
minute,
let
me
know.
C
Sounds
good
Emily.
B
Cool
thanks,
hey
everyone,
welcome
the
thank
you.
B
I
can
see
a
couple
familiar
faces
in
here
too,
so
the
micro
profile
Telemetry
folks,
which
I
think
Emily's
been
on
here
before
to
kind
of
representing
that
we're
looking
at
we're
just
trying
to
get
some
advice,
I
guess
about
what
we
should
do
as
our
kind
of
go
forward
approach
to
adding
new
spans
and
new
metrics,
so
micro
profile
Telemetry
has
microprofile
as
other
specs
like
fault
tolerance,
that
today
you
know,
uses
metrics
and,
and
you
know
we
have-
we
have
different
cases
for
within
micro
profile
that
create
spans
like
microprofile,
rest
client,
for
example,
and
currently,
in
the
past
release,
we've
done
the
instrumentation
of
the
spans
by
requiring
the
micro
profile
piece
that
sits
on
the
runtime
to
use
the
otel
API
to
create
the
spans
and
I'm
coming
at
this
kind
of
in
the
second
release
of
this
saying,
like
is
that
the
right
approach
that
we
should
be
doing
because
I
know
you
guys
have
a
whole
set
of
supported
libraries.
F
B
Don't
know
if
we're
doing
it
wrong
by
us
approaching
it
as
something
that
sits
on
top
of
the
runtime
using
the
API
to
add
the
micro
profile
spans
and
eventually
metrics
so
I
guess.
My
broad
question
is:
are
there
key
limitations
as
to
why
some
people
go
off
and
do
it
themselves
with
the
API
even
for
Frameworks?
Or
would
you
guys
think
that
for
Frameworks
we
should
always
be
looking
to
try
to
figure
out
how
to
contribute
that
to
the
Java
agent
instrumentation.
C
Yeah
so
yeah,
it's
a
great
question,
and
so
we
are
open.
Telemetry,
the
big
high
level,
open,
Telemetry
vision
is
definitely
to
have
Frameworks
use
the
instrument,
the
open,
Telemetry
apis
directly,
because
that's
the
only
way
it
can
really
scale
and
Java's
been
lucky
that
we've
had.
C
You
know
a
good
number
of
a
lot
of
maintainership
and
a
lot
of
effort
to
kind
of
bootstrap
this
process
and
build
these
library
instrumentations
and
the
Java
agent
instrumentation
for
people,
but
especially
if
you
look
at
other
languages
and
and
Java
also
is
definitely.
The
long-term
vision
is
to
have
that
Frameworks
instrumenting
themselves,
following
the
open,
Telemetry
semantic
conventions.
C
B
So
I
I
get
what
you're
saying
I
guess
I
guess.
My
question
is
why,
for
the
for
the
initial
list
of
all
these,
it
seems
I.
It
feels
almost
inconsistent
to
say
that
the
you
know
things
like
Drax,
RS
or
other
things
that
are
part
of
the
list
of
supported.
Libraries
are
I,
see
them
in
the
list
right,
so
I
see
lots
of
things
like
HTTP
and
other
things
that
are
in
the
list
of
existing
supported.
Libraries.
B
So
is
that
is
that
just
a
matter
of
you,
you
wanted
to
do
that
as
a
common
Java
agent
thing
to
get
this
off
the
ground,
and
then
the
intent
was
always
that
people
would,
through
their
Frameworks,
just
do
their
own
thing
on
top
I'm,
just
trying
to
see
what
what
was
the
philosophy
of
of
stuff
being
in
the
agent.
C
So
I
think
that
yeah
I'd
say
primarily:
the
agent
exists
because
of
boot
I
mean
I
would
say,
because
of
bootstrapping,
and
because
we
had
a
good
initial
contribution
of
the
code
base
from
datadog
and
we
had
it
was
a
good
way
to
bring
on
and
with
you
know,
in
the
Java
ecosystem.
We've
had
really
great
adoption
because
of
the
Java
agent.
C
It's
just
really
simple
for
people
to
do
and
to
get
into
the
open
Telemetry
space,
and
it's
definitely
a
problem
that
our
group
will
have
to.
You
know
figure
out
how
we
make
that
long-term.
You
know
transition,
but
it
really
is
the
long-term
vision
of
open
telemetry
as
a
whole
is
Frameworks
in
provide
doing
native
instrumentation.
B
Okay,
all
right
coin,
I
get
the
I
think
I
get
the
bootstrapping
point
too,
which
is
that
you
would
have
never
got
off
the
ground
with
so
many
components
all
at
once.
If
you
had
to
work
with
all
those
individual
components
to
get
them
to
actually
use
the
API,
so
it
was
kind
of
expedient
to
use
bytecode
injection
to
get
that
first
set.
C
And
it's
a
chicken
and
egg
problem
of
in
order
to
get
big
projects,
especially
to
adopt
open
Telemetry.
We
had
to
prove
that
open
Telemetry
was
successful,
yeah
and
so
yeah.
So
we're
kind
of
I
think
we're
we're
hoping
to
be
reaching
that
Tipping
Point
soon,
where
we
can
start.
You
know
really
working
with
more
Frameworks
and
community
in
that.
Taking
that
Vision
forward.
B
All
right,
yeah,
I,
think
for
for
now
I'm
that
that
makes
sense.
So
thanks
trash
can
chuck.