►
From YouTube: 2023-02-17 meeting
Description
cncf-opentelemetry@cncf.io's Personal Meeting Room
A
B
A
F
B
E
These
this
is
starting
to
come
together
other
than
the
ECS
stuff.
E
Yeah,
so
let's
start
with
this
one,
because
there
were
questions
about
whether
we
needed
to
add
normative
language
here
is
that
do
you
think
that's
the
only
thing
here:
would
it
help
if
I
just
go
through
and
capitalize
shoulds.
F
Yeah
I
mean
that's
yeah,
I
think
so,
if
all
we
have
to
do
is
I
can
see
these,
we
need
to
be
non-spec,
I've
been
reviewing
them
for
requirements.
We
need
to
implement.
F
F
This
is
my
PR
rate.
Yeah
I
can
go
through
and
do
that
that's
not
a
problem.
It's.
It
is
disturbing
that
people
didn't
consider
these
spec,
though
we
have
a
bunch
of
readme's
that
are
specs
in
the
specification
like
if
it's
underneath
the
specification,
repo,
it's
the
specification.
Unless
it
explicitly
says
it's
not
spec,
we
should
treat
it
as
a
spec
just
going
forward.
E
Just
to
if
anyone
has
a
chance
to
review
this,
what
a
little
militant
here
is.
Oh,
hey,
look,
Miller,
bye,.
E
G
Yeah
but
unfortunately
it
thing
it
should
capture,
it's
not
necessarily
an
AP,
so
it's
IEP
or
IEP
port
or
an
obfuscated
name
according
to
the
RFC.
So
it
feels
like
reusing
AP
is
not
great
and
also
like.
Extending
this
approach
to
other
parts
of
forwarded
header
would
introduce
things
like
client,
Proto
or
client
host
or
client
buy,
which
is
just
not
not
intuitive,
so
it
doesn't
feel
like
ECS
attribute
is
a
great
choice
either,
and
they
also
circling
back
on
defining
some
conventions
for
proxies.
E
This
does
match
PCS,
but
it's
also
I
think
what
we
would
want
to
do
even
without
ECS,
is
currently
black
done.
Some
weird
schema
parsing
thing
that
the
go
team
is
investigating
but
feel
free
to
review
it
just
for
the
change
itself
and
that
we
don't
have
any
Rush
on
I
think
the
goal
is
just
to
kind
of
accumulate
approvals
on
these
PRS
but
hold
on
merging
them
until
we
kind
of
do
maybe
all
of
the
changes
all
at
once
in
one
spec
release
sort
of.
E
Linmilla
opened
this,
we
went
over
this
thanks.
Let
me
know
we
went
to
Josh
and
Armin
and
I
went
over
this
in
yesterday's
General
sink
and
so
I
think
this
is
resolving
this
one
and
there's
one.
You
also
set
one
for
this
stability.
G
F
Well,
this
does
two
things
because
the
the
documents
Mark
stable
and
it
says,
what's
allowed,
but
it
doesn't
it
if
you
were
to
strictly
read
how
it's
worded.
It
means
you
actually
can't
change
like
the
values
of
metrics
that
you
write
and
crap
like
that,
because
that's
not
allowed
as
a
change
so
like
what
I
did
was
I
first
said:
here's
what's
included
in
stability
and
everything
else
can
change
at
any
time,
because
it's
considered
a
runtime
value.
We.
B
F
F
No,
we
we
talked
so
when
was
that
Wednesday
we
want
to
add
so
we
want
attribute
requirement
level
and
we
wanted
to
add
one
for
metric
name.
That
looks
exactly
the
same,
so
we
think
we
need
that.
But
I
think
you
could
take
this
one
and
Market
stable
and
then
add
a
new
document
for
the
metric
name
thing
yeah.
E
Yeah,
that
is,
that
that's
on
me
and
I'll.
Do
this
one
also
since
I'm
doing
the
metric
requirement
one
and
there
was
Armin
had
suggested
renaming
this
to
opt
in.
E
G
E
E
I'm
trying?
Oh
yes,
yes,
so
this
one
is
what
we
discussed.
E
Don't
wanted
the
gauge
does
if
this
is
bothers
anybody
else,
I
I
can
drop.
This
I
I
find
this
net
app
namespace
confusing
every
time.
I
see
it
because
I
don't
think
in
terms
of
application.
Protocol
versus
transport
protocol,
but
I
understand
what
it
is.
E
I
couldn't
unders
I
couldn't
Cipher
from
his
response
here.
E
It's
also
potentially
we
would
it
would
like.
If
we
do
the
ECS
alignment,
we
would
do
Network
protocol
Network
transport,
so
yeah.
F
G
I
think
he
doesn't
have
a
context
about
DCS
alignment
and
he
assumes
that
we
will
use
HTTP
version
instead,
so
I
can
try
to
explain.
This
is
not
the
case,
and
maybe
it
will
convince
him.
E
C
G
Yeah,
and
not
just
for
http
and
also
like
messaging
conventions,
are
in
quite
unstable,
State
and
all
changes
should
be
expected.
There.
I
can
chat
to
us
messaging
crew
and
ask
if
they
have
any
objections,
but
I
also
take
a
liberty
to
say
they
probably
would.
B
E
Yeah
and
I,
since
we
haven't
done
the
labor
since
we
haven't
done
this
change
on
the
HTTP
side
anyway,
yeah.
C
So
I
I
was
kind
of
speaking
in
context
of
this
change.
I
agree
moving
flavor
and
using
HCB
like
the
net
protocol,
because
then
you
would
have
the
same
attributes
and
like
both
messaging
and
HTTP
and
possibly
like
RPC
or
other
even
conventions.
C
D
Yeah,
but
in
the
same
time
we
are
losing
this
kind
of
application,
Level
notation
right,
so
we
don't.
We
don't
know
like
if
it
like.
What
is
the
layer
is
I'm,
not
sure
if
it
I
don't
know
if
it's
like
important
or
not,
but.
E
So,
do
you
like
Dennis,
like
what
do
you
think
of
net
transport
protocol.
D
D
A
D
G
E
E
Sorry,
oh
yeah,
yeah,
okay,
I
think
that's
some
enough
I
will
will
keep
exploring
this
Mateus.
We
finally
have
time
to
talk
about
connection
HTTP
connections.
C
Yeah,
so
I'm
not
sure
if
you
follow
it
to
the
issue
that
I
made
but
like
to
cut
the
long
story.
Short
it's
pretty
much
about
what
the
HTTP
span
is
supposed
to
like
mean
or
whether
it's
an
like
the
entire
high
level.
Each
sending
an
HTTP
clients
fund,
whether
it's
like
high
level
sending
of
an
HTTP
request,
whatever
it
entails,
or
whether
it
is
a
single
attempt
to
send
actually
send
the
request.
Over
The
Wire,
so
I
started
going
into
this
Rabbit
Hole.
C
When
I
tried
to
implement
the
recent
counts
spec
in
the
Java
instrumentation
agent,
and
it
turns
out
that
some
or
maybe
even
most
instrumentations,
that
we
have
well.
We
will
not
be
able
to
implement
the
recent
counter
in
like
a
huge
number
of
them,
because.
C
Reasons
whether
they
are
like
library
instrumentations
that
do
not
like
allow
us
to
capture
like
very
low
level
details
or
whether
the
in
the
Java
engine
instrumentations,
the
library
instruments,
are
not
structured
in
a
friendly
way.
That
would
allow
us
to
do
the
same
or
whether
it's
something
like
AWS
SDK,
which
signs
the
requests,
and
it's
like
not
possible
to
capture
details
about
every
single
recent
attempt,
because,
like
trying
to
inject
the
propagation
headers
would
like
mess
up
the
sum.
Let's
check
some
so.
C
Yeah,
the
question
is
right
now:
I
I
think
it's
pretty
unclear
what
the
HTTP
span
is
supposed
to
mean
whether
it's
like,
like
the
whole
thing
totally,
including
like
establishing
connection
like
whether
it's
like
creating
it
first
like
opening
a
new
connection
or
taking
it
from
a
connection
pool
whether
it
includes
a
very
recent
attempts
like
authorization
or
500
errors
and
stuff
like
that
or
whether
it's
supposed
to
be
like
the
low
level
single
Cent
attempts
things
the
and
like
taking
all
this
technical
difficulties
of
actually
implementing
implementing
the
recent
I
think
we
should
probably
have
two
options
like
we
should
allow
the
instrumentation
others
to
either
like
Implement
like
low
level
hdp
instrumentation,
which
would
treat
the
HTTP
spans
as
like
a
single
attempt
to
send
the
request.
C
Over
The
Wire
and
these
kind
of
instrumentations
would
have
to
implement
the
retry
counter
the
recent
counter-
and
there
is
the
matter
of
like
establishing
the
connection-
it
usually
happens
before
sending
a
request.
So
it's
like
a
new
like
type
of
span,
because
it's
not
strictly
an
HTTP
span.
C
C
And
the
other
option
for
all
those
I
think
that
the
low
level
instrumentation
we
preferred
one,
because
it's
it
gives
more
details
about
what
actually
happens
and
the
other
is
like.
The
high
level
instrumentation,
which
is
just
like,
like
creators
HTTP
span
for
like
the
topmost
HTTP
client
operation,
that
you
can
so
in
case
of
the
like
in
case
some
recents
happen.
Inside
of
here,
the
HTTP
client
instrumentation
will
be
apparent
of
like
several
server
spans,
whether
it's
like
for
redirects
authorization
or
something
like
that.
D
Yeah,
actually,
we
had
similar
discussions
I
think
last
year
about
all
this
stuff,
and
we
were
talking
about
retrace
and
redirects
and
actually
right
now
in
specifications
we
are
stating
that,
like
a
red,
rice
and
redirects
should
cause
like
a
physical
span
to
be
created,
So
currently
in
HTTP
spec
we're
actually
stating
that
the
first
option
from
this
one
should
be
kind
of
implemented
yeah,
but
yeah
I
do
remember
that
we
tried
to
do
that
with
with
several
languages
like
a.net
was
there
we
tried
to
do
this
with
Nila
in
Java
and
I
think
we
do
have
a
prototype
in
Python,
so
some
difficulties
are
there
definitely
but
like
if
it
is
kind
of
doable
generally
but
yeah.
D
Maybe
we
can
revisit
this
this
decision
this
time.
If
we
have
like
this,
this
concern
race
once
again,
yeah.
C
So
I,
just
like
have
two
problems
with
the
low
level
HTTP
instrumentation
one
is
that
there
are
like
some
instrumentations
there's
some
a
number
of
instrumentations
that
you
just
can't
instrument
this
way,
it's
just
not
possible
and
the
other
one
and
the
other
one
I
think
is
more
important,
is
about
any
sort
of
connection
Telemetry
connection
issues
like
if
you
try
to
open
the
connection
to
I,
don't
know
when
you
pass
some
like
hostname
that
doesn't
exist
and
like
we
could
return
the
DNS
error,
this
kind
of
low
level
instrumentation
will
not
capture
that
because
it,
it
all
happens
before
the
HTTP
request,
is
attempted
to
be
sent
over
the
wire.
D
Right,
yeah,
I,
I
I,
know
what
she
means
like
in
in
Jawa.
Sorry
in
JavaScript,
it
wasn't
possible
like
even
to
do
this
on
a
client
side
right,
so
there
is
no
context
that
you
can
can
be
propagated
to
a
kind
of
physical
connection
level.
So
yeah,
that's
why
we
put
shoot
there
so
currently,
like
a
recent
count,
is
stated
as
should
but
yeah.
The
thing
is
that
so
yeah
trust.
If
you
can
open
HTTP,
instrumentation
or
a
specification,
we
do
have
a
couple
of
examples
there.
D
Basically,
if
we
can
somehow
capture
this
physical
spans,
it
actually
simplifies
the
overall
kind
of
the
overall
analysis,
a
lot
right,
because
we
can
see
all
this
stuff
like
immediately
right.
So
we
see
that
we
had
a
retry
on
a
physical
level
and
yeah.
That's
the
example.
D
So
and
then,
if
something
went
wrong,
we
can.
We
can
just
see
all
this
like
a
500
or
something
so
yeah.
G
I
understand
that
we
don't
have
to
like,
we
should
write
in
the
spec
what's
best
right
like
how
we
see
should
work,
but
we
should
allow
for
things
that
don't
fit
into
this
because
of
some
implementation.
Difficulties
right
and
I
think
that
the
current
spec
attempts
to
do
this.
It's
just
the
question
how
we
capture
this
extra
thing
like
how
do
we
allow.
C
So
all
these
examples
are
like
obviously,
very
useful.
I
mean
I
like
modify
some
of
them
even,
but
there
is
like
there
is
no
example
that
will
show
you
what
happens
if
you
like
totally
do
not
call
the
server
at
all
because,
like
you
lost
the
internet
connection-
and
you
probably
usually
want
to
have
a
span
for
cases
like
that,
because
this
kind
of
error
is
something
you
would
probably
like
to
see
in
your
opportunity.
The
uni
or
observability
back
end
of
choice.
D
Yeah,
that's
that's
true,
so,
like
basically,
the
way
the
way
how
I
so
yeah
two
questions
here,
the
first
one
like
I,
should
be
still
like
a
revisit
the
decision
that
it
should
be
low
level
only
or
high
level,
only
or
both
of
them
or
and
the
second
one
is
how
we
should
like
which
verb
should
put
there
the
currently
it
should.
Maybe
we
should
relax
it
to
kind
of
May.
G
I
would
actually
suggest
that
we're
right
there
say
that
to
capture
this
information,
instrumentations
May
create
high
level
span
and
I
can
explain
why
I
may
and
not
shoot,
but
also
like,
but
I
assume
that
what
could
happen
that
there
is
an
assumption
that
there
are
certain
phase
happens
before
the
first
try,
but
I
also
assume
in
some
cases
it
happens
within
the
first
try.
So
it's
very
hard
to
say
not
only
specific
client
instrumentation.
Well,
no
right
also,
there
are
some
many
instrumentations.
G
D
A
D
G
C
G
Os,
do
you
know
if,
in
these
cases
we
can
do
something
better
than
that?
So
can
we
add
events
that
represent
individual
tries
or
do
we
know
anything
about
it
at
all,
foreign.
C
E
C
C
Some
of
the
HTTP
client
libraries-
don't
really
like
expose
anything
that
would
like
even
tell
you
how
many
attempts
were
made
so
that
I
would
say
that
this
is
the
major
problem
when
it
comes
to
the
slow
level
Asian.
G
I
assume
in
their
case
their
cases
reprise
or
this
Network
retries,
because
if
they
allow
you
to
specify
retry
policy
the
status
quo,
they
should
allow
you
to
like
that.
Each
of
the
school
is
physical
spent.
In
fact,.
C
G
E
I
didn't
follow
what
you
said
about
being
able
to
capture
that
every
try,
because
I
thought
that
was
part
of
the
problem
we
were
facing
on
some
of
the
library
instrumentation,
is
that
we
couldn't
capture
that
lower
level.
G
Yeah,
so
there
are
two
problems
right,
so
usually
all
everyone
in
the
world
wants
to
retry
Network
record,
failed,
Network
requests
right
connection,
drops
came
out,
it
happens
right,
but
if
you're
a
dry
I
don't
know
even
429
is
is
very
custom
depends
on
the
service,
so
HTTP
clients
usually
provide
you
hooks
to
specify
your
retry
Handler
or
something
or
at
least
intercept
an
individual
requests,
but
they
can
retrieve
this
connection
failures
by
default
without
ever
notifying
you.
G
C
Yeah
I
would
say
that
it
also
depends
on
the
HTTP
client,
because
I
started
by
trying
to
modify
okay,
HTTP
client,
and
it
turns
out
that
it
basically
just
gives
you
everything.
So,
even
if,
like
there's
a
connection,
failure
like
the
connection
got
closed
and
it
needs
to
be
reopened
and
there
should
be
your
business
to
be
sent
again.
We
still
get
this
information,
so
probably
some
others
DP
clients
do
not
give
you
this
much
information.
G
D
Yeah
and
actually
I
like
this
idea,
so
if
some
hooks
are
available
for
HTTP
client,
then
we
can
say
that
the
possibility
is
there
right.
So
we
can.
We
can
actually
capture
this
information
and
actually
create
spans
for
every
physical
HTTP
read
write.
Definitely
when
it
when
it
comes
to
transport
level
like
a
product
or
I
mean
socket
level
or
like
in
TCP
or
whatever.
D
We
probably
cannot
do
this
right.
We
cannot
capture
retries,
but
here
we
want
to
focus
on
HTTP
level,
only
not
go
that
deep,
so
yeah,
so
it
really
depends
on
HTTP
client.
If
it
provides
you
this
ability,
then
it's
doable
and
maybe
that's
something
that
we
can
reflect
in
our
specifications
and
that
if
you
have
this
possibility,
just
do
your
best
to
do
that.
If
it's
something
that
is
totally
unavailable
for
you.
Well,
that's
that's
nothing
to
do
here.
You.
E
E
E
Have
a
great
long
weekend
for
those
of
you
in
the
states.