►
From YouTube: 2023-02-24 meeting
Description
cncf-opentelemetry@cncf.io's Personal Meeting Room
A
C
D
D
A
So
Josh
reached
out,
and
he
said
that
he
won't
be
able
to
make
it
today,
but
I
think
we
should
have
thus
joining
us
in
a
few
seconds.
F
Chat
about,
but
without
Josh
here,
I'm,
not
sure.
D
If
we
want
to
sorry
I'm
trying
to
share.
D
A
Let
you
copy
it
over
the
cloud:
formatting!
That's
not
working
on
Heaven,
okay,.
B
If
you
try
pasting
with
shift,
it
should
be
ready
for
my
thing.
D
A
D
F
F
F
We
need
something
we
want
I
guess
you
know,
I,
guess
the
in
the
Java
instrumentation.
We
want
something
to
be
able
to
say
hey
this
connect
failed,
because
without
that
we
have
no
way
of
communicating
basically
to
our
users
that
something
failed,
because
we
can't
emit
a
HTTP
span
at
that
point,
because
we
don't
even
know
if
it's
going
to
be
a
post
or
a
get.
B
Yeah
with
one
one,
if
I
may
like
interrupt
you
with
one
minor
okay
bit,
is
that
right
now
it's
just
Daddy
I
mean
the
current
implementation
job
in
the
Java
agent.
But
if
we
were
to
implement
the
recent
spec
as
it
currently
is,
it
would
be
much
more
based
limitations.
That
would
behave
this
way.
F
Got
it,
and
so
we
could
I
mean
we
can
consider
that
connect,
maybe
outside
of
HTTP
semantic
conventions,
but
we
still
we
as
the
Java
instrumentation
would
still
need
to
emit
something
for
our
users
for
that
and
so
I
think
part
of
Arkansas.
The
concern
is
being
able
to
stabilize
release
stable
instrumentations
without
having
that
connect
being
defined,
which
I
guess
maybe
first
wish
like.
If
there's
a
is
there
agreement
that,
like
it
could
be
outside
of
this
HTTP
spec
or
it
should
be
part
of
the
HTTP
spec.
B
E
It
will
be
somewhat
hard
to
Define
what
connect
means,
because
for
several
clients
at
least
it
happens,
it's
hidden
from
the
instrumentation.
It
happens
within
the
first
try
and
they
never
expose
it.
So
it
will
be
very
hard
to
Define,
but
I
guess
the
brand
is
that
we
need
to
explain.
There
was
a
failure
to
users
like,
and
it's
probably
an
exception
or
event
of
some
sort
or
log
record,
or
maybe
a
spotlight
I
think
it's
it's
a
categorized
place
right
now
right,
but
we
need
more
generic
way
to
capture
all
of
possible
tailors.
G
Yeah
for
me,
it
sounds
that,
like
we
have
different
layers
of
of
networking
stack
right
and
we
probably
have
different
semantic
conventions
here,
and
we
are
talking
about
how
how
to
connect
these
different
semantic
connections
to
each
other.
So
from
a
user
perspective,
it
will
be
obvious
what
what
happened
right
so
and
basically
for
me,
it's
question
like
do.
G
So
should
we
have
this
like
a
tree
diagram
here
or
it
should
be
just
sequential
diagram?
That's
that's
something
that
I
can
cannot
really
understand.
C
A
I
think
it
wouldn't
be
breaking
for
the
semantic
conventions
themselves,
but
for
the
instrumentation
right.
D
A
C
C
F
So
I
think
we
wouldn't
I,
don't
think
we
would
make
the
Java
instrumentation
stable
without
this,
because
we
wouldn't
want
to
release
the
Java
instrumentation
without
capturing
something
on
those
failures,
and
so
we
would
probably
need
to
stick
to
you
know
an
experimental
connect
or
some
kind
of
failure,
but
but
that
also
is
similar
problem
we
have
with
exceptions
today
is
like
I.
Don't
think
we
would
declare
the
Java
instrumentation
stable
without
declaring
exception
semantic
conventions
stable,
since
that
is
also
part
of
our
Java
instrumentation.
Is
we
catch
and
record
exceptions.
F
F
E
I
think
we
have
some
sort
of
consensus
in
how
we
can
address
it
and
if
I
recall
correctly,
we
can
address
it,
not
necessarily
an
https
pack,
but
in
a
generic
way
we
don't.
Maybe
we
will
need
some
special
convention,
but
maybe
it's
not
the
HTTP,
and
if
we
can
go
through
the
solution
and
see
that
this
group
is
not
a
post,
then
we
have
an
answer
right.
We
can
say:
Okay
HTTP
is
good
and
we
know
how
to
address
this
problem.
Do
you
feel
the
same
attached
or
I'm
missing
something
yeah.
B
I
actually
like,
like
your
idea
and
like
my
very
last
comment
and
I,
just
posted
like
a
half
an
hour
ago,
I
quickly,
summed
it
up
on
those
clubs
a
little
bit.
B
It's
a
trust.
Can
you
scroll
up
a
little
bit,
and
here
it
is
like
the
last
paragraph.
So
we
could
just
emit
or
like
say,
should
or
may
I
mean
some
kind
of
like
outer
span,
which
could
be
a
simply
an
internal
span.
B
That
lies
the
code
semantics
so
that
we
at
least
have
some
kind
of
knowledge
about
the
class
and
the
method
name,
which
also
could
be
useful
for
sampling,
I,
believe
and,
like
my
only
question,
is
whether
we
would
want
to
mention
like
this
line
that
HTTP
instrumentation
should
or
may
emit
this
kind
of
span
and
the
HTTP
file
itself
or
whether
it
should
be
like
pulled
out
somewhere
else.
F
So
I
for
Nettie
How
would:
how
would
we
emit
an
outer
span.
B
We
wouldn't
okay
and
I'm.
Okay
with
that
honestly,
because
Nettie
is
like
it's
an
exception
to
like
every
other
instrumentation
that
we
have
and
that
it
doesn't
have
like
a
top
level
interface,
because
it's
a
very
low
level,
networking
Library,
it's
not
an
HTTP
client.
You
can
use
it
as
an
HTTP
client,
but
it's
not
an
HTTP
client.
And
there
is
this
Infamous
issue
created
by
Nikita
about
not
instrumenting
the
clients,
which
also
is
like
a
valid
data
point
here.
D
C
D
F
Yeah,
maybe
would
you,
when
you
have
time
to
maybe
put
a
prototype
for
reacternity
and
maybe
the
I
know
you
had
started
the
okay
HTTP,
because
I
think
a
couple
prototypes
would
help
make
that
yeah
extra
clear.
So.
B
I
I
also
update
this.
This
BR
is
to
reflect
this
our
discussion
with
Mila
the
week
after
the
next
video
because
I'm
off
next
week,
so
it
will
be
stay
a
little
bit.
G
Yeah
one
one
question
or
clarification
here:
so
can
we
put
it
as
as
May
just
because,
as
you
mentioned
like,
we
don't
have
much
except
like
a
much
examples
when
we
actually
can
do
this,
and
maybe
we
can
put
it
as
optional
stuff
like
not
another,
something
that
users
need
to
opt
out
but
other
way
around,
maybe
users
might
want
to
opt
in
to
have
it.
What
do
you
think?
G
Basically,
it's
like
a
something
which
is
not
not
default,
which
which
follows
the
current
semantic
conventions
and
basically
that's
gonna,
an
addition.
That's
users
or
maintainers
for
instrumentation
libraries
could
do
if
possible
and
it
actually
clarifies
the
overall.
G
D
E
So
during
that
request,
you
have
you
have
different
things
like
the
DNS,
the
connect
tries,
you
can
get
interrupted
or
came
out
exception
between,
tries
right,
you
can
I,
don't
know
your
application
can
stop,
or
it
probably
is
not
in
school.
Anyway,
you
read
the
response
after
the
response
stream,
the
response
body
right
after
you
made
a
successful
request
and
things
can
happen
there.
E
So
if
it's
present
it
should
group
all
of
those
things
not
just
tries,
but
if
there
is
no
such
thing,
then
probably
there
is
another
span
right
very
likely
like
can
come
and
get
HTTP
request
or
something
else
that
would
also
group
down
plus
more
right.
So
absence
of
the
span
is
not
terribly
bad.
B
G
Yeah,
maybe
maybe
you
remember-
we
had
the
discussion
last
year
as
well
about
this.
This
particular
topic,
like
I
shouldn't,
be
top
outer
span
or
not
and
yeah.
In
most
practical
cases,
it
will
be
some
some
outer
span,
which
is
exist
already
like
incoming
requests
or
operation
start
like
something
which
was
instrumented
before
and
all
the
retries
will
actually
be
children
of
of
that
of
that
span.
G
So
but
in
case
we
want
to
add
it,
it
basically
just
kind
of
duplication
and
it
last
year
it
was
an
idea
to
actually
how
we
can
link
these
tries
together.
So
we
can
kind
of
reproduce
the
the
sequential
how
they
happened
so
like
it
was
an
idea
to
use
links
for
that.
Maybe
it's
like
a
two
two
heavy
to
do
that
right
now,
but
it's
something
that
can
be
considered
as
Elder
interval.
G
Yeah
and
that's
that's
probably
something
that
people
in
messaging
as
many
conventions
consider
to
do
right
so
I
mean
all
these
links
or
maybe
I'm
not
following,
but.
E
D
G
Yeah
so
I
think
this.
This
logical
span
like
in
most
cases
as
I
said
it
is
already
exist,
and
actually
we
have.
We
do
have
some
examples
in
the
current
version
of
the
specification
when
it
is
mentioned
that
okay,
so
if
it's,
if
it's
there,
then
the
picture
looks
like
looks
like
exactly
the
the
way
how
you
how
you
draw
here.
B
I
think
it's
true
that
in
most
cases
we
have
an
outer
span
and
I
like
almost
agree
that
we
don't
need
it.
There's
like
one
thing
that
I
can
think
of.
Is
that,
let's
say,
for
example,
you
have
like
a
service
plan,
you
receive
the
HTTP
request
and
the
direct
child
of
the
service
plan
would
be
HTTP
clients
panel,
like
multiple
HP,
client,
specs
in
case
any
sort
of
like
networking,
layer
issue
or
parsing.
I
o
stuff
happens
all
those
exact.
B
F
I
think
I
didn't
follow
One
Step
there.
Why
would
the
exception
be
on
the
oh?
Because
the
point
of
this
was.
B
B
B
E
At
the
same
time,
if
I'm,
a
user
I
just
added
Java
agent
or
configured
up
until
entry,
I
got
the
picture
where
my
child
tries
and
the
exceptions
are
mixed
together,
one
of
the
possibilities-
I
go
and
I
address.
An
annotation
I
have
to
write
my
code
in
a
certain
way
that
it
works
right.
I
have
to
discover
that
there
is
such
annotation,
but
I
will
get
it
as
obtained
relatively
cheap.
The
first
the
first
discovering
the
span
will
be
hard,
but
then
users
as
they
work
on
their
applications.
E
E
Maybe
we
should
add
the
connect
spend,
maybe
it
will
improve
things
and
seriously.
Maybe
we
need
to
DNS,
but
it's
it's
just
both
things
make
sense.
F
What
if
we
just
would
have
worked
to
like
if
we
didn't
have
this
logical
span
and
then
any
errors
happen,
and
we
just
record
that
error.
E
F
E
G
Yeah
actually,
but
that's
a
good
point
right
if
you
want
to
also
link
logs
and
spans
together
like
a
traces
together,
then
for
lock
record
with
the
the
corresponding
exception,
it
will
be
spam,
ID
or
of
let's
say,
a
try
or
basically
the
the
this
band
which
which
was
there,
which
was
there
active
when
the
exception
happens.
G
So
like
it's,
it's
it's
understandable
that
we
want
to
reproduce
this
picture
from
the
traces
perspective,
but
I
mean
it's
somehow
kind
of
looks
like
somehow
Arctic
artificial
that
we
want
to
like
make
it
so
perfect
in
reality.
That
might
be
different.
F
G
C
C
And-
and
my
point
is
we
shouldn't
say
you
should
do
something,
because
in
many
cases
people
cannot
but
it's
okay,
everything
you
may
and
whatever
we
want
to
say
like
you
may
do
something
we
we
probably
should
have
a
principle
like.
We
don't
want
to
give
too
much
noise
to
the
users.
We
don't
assume
that
by
giving
something
that
we
believe
is
built
for
by
causing
them
extra
things.
They
will
appreciate
that.
F
So
this
is
only
applying
to
I
mean.
Do
you
have
the
same
concern
Riley?
If
this
is
only
applied
to
low
level
instrumentations
I.
B
So,
like
low
level
is
the
band
the
actual
HTTP
request,
Over,
The,
Wire
and
high
level
is
like
a
like.
If
you,
if
you
can't
instrument
like
every
single
retry
resend,
then
you
just
just
remember
the
topmost
operation.
D
F
Think
how
I
would
maybe
describe
that
as
like?
Basically
in
this
particular
the
if
there
are
failures
that
can
happen
as
part
of
that
get
that
wouldn't
be
captured,
then
you
should
emit
a
logical
outer
span.
F
Is
there
a
way
when
we
record
say
we
record
that
exception
on
that
parent
service,
the
service
ban
coming
in?
Do
we
know
that
that
is?
Do
we
have
a
way
of
differentiating
between
the
exception
that
failed,
the
server
span
and
just
a
random
exception
that
we
recorded
along
the
way.
B
Is
also
a
possibility
that
the
exception
might
be
called
like
somewhere
in
the
middle
before
it
is
added
to
the
service
band,
and
there
is
an
error
occurring
somewhere
where
there
would
be
like
DNS
or
connection
or
trying
to
parse
the
response
and
users.
Don't
ever
see
any
of
that.
F
Right
but
if
we
called
at
current
span
record
exception
here,
okay.
B
G
Actually,
it
might
be
several
exceptions
right,
it
might
be
when
we
try
to
get
like
a
two
percentage,
some
requests-
it
might
be-
DNS
exception,
it
might
be
TLS
exception,
it
might
be
just
TCP
or
wherever
it
is
exception.
So,
if
you
want
to
capture
information
like
these
details,
it's
probably
will
be
a
good
idea
to
kind
of
introduce
specific
spans
for
for
each
kind
of
layer
right
but
again,
like
I
have
to
like
Israeli.
It
will
be
too
noisy
if
you
want
to
Define
it
by
default.
G
C
F
I
mean
that
seems
without
the
logical
that
seems
to
capture
in
the
data
model
pretty
well.
The
only
problem
that
I
have
is
in
our
exporter,
like
from
a
consumer
perspective,
usually
I
I
expect
that
probably
maybe
wrongly
expect
that
exception
to
be
like
an
exception
that
caused
a
failure
on
the
span,
but
maybe
that's
maybe
that's
just
a
incorrect.
B
I
would
also
expect
this
because
I'm
not
sure
if
I
have
ever
seen
a
span.
That
has
two
exceptions
since
I
started
working
in
open
telemetry.
C
Yeah
that
works,
assuming
that
there's
only
one
exception,
we're
expecting
a
stack
of
exceptions
like
one
from
the
TCP
layer.
Then
later
there's
another
upper
layer,
it'll
be
harder
to
model.
F
We
can
record
those
along
the
way
that
yeah
and
then,
but
still
having
that
concept
of
what
was
the
exception,
that
bubbled
up
all
the
way
to
the
server
span
and
caused
the
server
span
to
fail.
B
G
Right,
but
is
it
the
purpose
of
traces
actually
to
provide
like
a
default
picture
to
user
I
mean
definitely
exception.
Is
there,
but
you
cannot
put
like
a
really
huge
string
there.
Right
all
the
exception
details,
that's
stack,
trace
and
so
on.
All
this
stuff
will
be
still
in
locks
right.
So
basically,
my
my
understanding
here
is
that
races
help
people
to
understand
what
happened
across
multiple
components
or
Services.
G
That's
the
nature
of
distributed
tracing
right,
but
if
you
want
to
get
to
low
level
details
what
happened
to
this
particular
replica
of
this
particular
service
at
that
particular
moment,
and
it
definitely
need
to
go
to
Locks
anyway
right
because
it
will
be
more
verbose,
information
which
helps
you
to
understand
what
happens
and
basically
just
linking
two
signals
together.
Help
you
to
understand
all
the
details
to
like
to
me.
Traces
is
useful,
but
I
don't
think
we
need
to
put
that
much
information
there.
D
F
Don't
know
I
mean
what
about
this
being
an
opt-in
feature
like
in
the
like
what
we
capture
a
lot
of
in
the
Java
instrumentation.
We
capture
control
internal
controller,
spans
that
also
I
kind
of
question
in
our
distro.
We
have
them
turned
off
and
they're.
F
Opt-In,
I
would
I
kind,
I
kind
of
aligned
with
Riley
on
that
case,
of
like
the
Telemetry
just
having
the
basics
by
default,
but
there's
definitely
a
lot
of
people
who,
like
those
controller
spans
to
be
able
to
have
more
context
of
where
they
are
and
would
want
to
have
this.
F
Cool
well,
let's
I
think
maybe
either
way
the
when
you're
back
matesh
kind
of
prototyping
a
little
bit
of
prototyping
on
the
nitty
reacternity
or
OK
HTTP
yeah.
C
And
my
suggestion,
like
we
should
say,
instrumentation
libraries,
May
and
friend,
individual
instrumentation
libraries,
depending
on
the
nature
of
that
Library.
Maybe
it's
Hopper
level,
maybe
it's
lower
level,
maybe
some
something
else.
The
library
should
have
freedom
to
decide
what
makes
more
sense
whether
to
include
The
Logical,
spend
by
default
or
not.
C
C
F
Cool
yeah,
then
we
could
Implement
in
like
in
the
Java
instrumentation.
We
could
have
basically
a
flag
we
could
have,
and
it
doesn't.
You
know,
whichever
way,
I'm
fine,
with
either
way
that
we
set
the
default
there
for
some
instrumentations.
As
long
as
we
have
a
flag
to
flip
that
yeah.
D
G
Yeah,
it
makes
us
to
put
it
as
May,
so
like
people
have
just
this
like
this
perception
that
it's.
If
it's
really
needed,
then
sure
you
are
free
to
go
and
and
Implement
that
but
yeah,
it
really
depends
on
the
language
and
the
platform
and
the
and
the
instrumentation.
So
for
some
for
some
people
it
might
make
sense,
but
I'm
just
impossible
to
do,
or
vice
versa
right,
so
yeah
I
think
we
can
like.
We
can
put
this
like.
G
We
can
add
this
flexibility,
but
yeah
I,
I,
really
I
really
look
really
well
to
the
idea
that
it
should
be
just
kind
of
some
basic
foundational
information
which
might
be
extended
if
needed.
B
Yeah,
that's
why
I
wonder
whether
we
wanna
put
this
into
the
HTTP
file
or
like
place
it
in
this
some
some
separate
self-confire,
like
HTTP
extra
hdb,
experimental
or
like
whatever.
F
Yeah-
and
so
I
mean
with
that
for
stabilizing,
do
we
need
this
to
stabilize.
F
B
I
mean
it
definitely
is
not
needed
for
like
some
con
stability,
but
without
like
a
good
answer
to
this
question.
I
would
didn't
feel
comfortable,
releasing
a
stable
like
Java
instrumentation
package,
where
she
declines.
F
B
D
F
B
I
wonder
like
how
I
like
really
how
practical
this
is
like,
how
many
of
the
exceptions
that
we
will
admit
will
be
non-ending
exceptions.
B
Almost
all
instrumentations
when
something
fails,
it
terminates
the
operation
and
we
like
end
the
span
of
an
exception,
and
it
pretty
much
means
that
it's
a
failure
right.
We
even
set
the
span
status
to
error
because
an
exception
has
happened
and
oh
yeah.
That's
we
actually
sort
of
already
have
this.
Like
I
mean
it's
fun
status.
B
If
you
have
an
exception
and
oh
yeah,
you
don't
know
which
one.
F
B
Because
it
was
a
500
or
something
or
a
user
manual,
instrumentation.
F
So
you're
just
talking
General
Trace
API,
not
HTTP,
semantics,
yeah,
yeah.
D
D
B
F
How
did
you
like
so
with
span
exceptions,
span?
Events
in
your
back
end
in
your
visualization?
Do
you
just
you:
are
those
just
like
logs
that
occur
within
a
span.
C
B
Spanish
reviews
I
mean
they're,
just
being
shown
like
you
know,
like
there's
a
substructure
of
an
event
that
even
has
unattributes
and
like.
A
D
B
I'm
not
like
the
expert
on
supplying
UI
stuff,
I
open
source
guy.
A
F
F
We
have
plenty
of
other
plenty
of
other
stability
dependencies
to.
D
B
And
again,
I
think,
like
the
semcon
is
probably
fine
without
this,
as
like,
like
without
the
constant
of
a
logical
span.
As
long
as
we
like
differentiate
between
the
low
level
high
level
spans
but
yeah,
maybe
I'll
just
split
this
PR
into
like
the
the
part
that
we
want
to
get
in
versus
the
experimental
part
that
will
contain
the
addition
of
this
logical
span.
F
Okay,
oh
does
the
first
answer.
The
first
part:
okay,
I,
see
split
that
out;
okay,
so
it
would
be
then
relying
on
record
exception
for
these
foreign.
B
Like
in
the
HTTP
clients,
bans
back
I.E
like
presented
two
ways
of
instrumenting
in
HTTP
client
like
there's
the
first
one
is
the
low
level
one
which
which
you
should
do
if
you
can
and
the
second
one
is
like
the
the
high
level
one
with
you,
which
is
like
the
fallback
scenario
in
case
your
library
or
your
environment,
or
whatever
doesn't
allow
you
to
instrument
every
single
recent,
so
I'll
leave
this.
D
B
Okay
have
a
good
weekend
then,
and.