►
From YouTube: 2023-01-26 meeting
Description
cncf-opentelemetry@cncf.io's Personal Meeting Room
A
B
A
D
All
right:
well,
let's
move
on
formalize
connect
spans.
B
Yeah
so
I
finally
started
working
on
implementing
the
HTTP
resent
when
we
try.
However,
you
call
it
spec
and
there
seem
to
be
a
few
issues
with
that,
like
the
probably
the
most
important
one
is
that
usually
in
I
I
can't
really
say
all
but
most
HTTP
clients
that
I
look
through
right.
That
I
read
the
resources
like
the
actual
sending
or
attempt
to
send
an
HTTP
request
happens
after
like
acquiring
connection,
and
usually
there
are
clearly
separate
inside
the
particular
HTTP
client
guns.
B
B
B
With
with
the
error
that
happened,
and
this
PR
removes
that
because
well
it
it
moves
the
like
the
HTTP
instrumentation
to
a
bit
later
phase.
B
So
if
we
want
to
implement
this
like
across
all
HTTP
clients-
and
we
probably
should
do
that,
if
we
want
to
implement
this
spec,
then
perhaps
we
should
do
something
about
the
connection
face
like
have
a
separate
little.
A
B
A
B
Well,
we
wanted
the
test
to
pass
in
Neti
and
we
want
to
like
people
who
use
Neti
based
clients
to
get
some
kind
of
Reader
information
if
they
run
into
connection
issues
exactly
because
that
he
has
this
like
says
this:
separation
between,
like
the
connection
phase
and
the
actual,
like
HTTP
request,
face,
and
usually
the
HTTP
clients
that
we
instrument
we
just
instrument
like
the
outermost
API
and
like
everything,
what
happens
other
than
if
we
don't
really
care.
B
D
And
so
I
was
just
trying
to
follow
how
so
it's
the
tests,
because
this
PR
updates
the
tests
that
cause
the
Neti
connect
tests
to
break.
B
No
Neti
is
is
an
example
of
an
instrumentation
that
already
like
has
faced
this
problem.
Can
you
open
the
okay
HTTP
request
yeah,
so
I've
changed
a
little
bit,
how
how
we
were
installing
the
interceptors
and
the
actual
HTTP
Interceptor
is
now
installed
as
a
network
interceptor,
which.
A
B
Case
of
Oak
HTTP
I
mean
I'm
sure
other
hdb
clients
have
like
similar
Concepts,
Network
and
interceptors
are
called
for
every
single
attempt
to
actually
send
an
HTTP
request,
Over
The
Wire-
and
this
happens
after
the
connection-
is
required.
B
So
can
you
already
had
this
issue
with
Neti
because
by
design
that
he
has
like
a
separate
connection
and
like
doing
something
with
the
socket
face,
and
we
will
face
the
same
problem
with
probably
almost
every
other
sleepy
client
that
we
will
want
to
instrument
if
we
wanna
implement
the
HTTP
reset
spec,
because
instead
we
we've
previously
treated
like
sending
an
HPT
request
as
like
the
whole
thing?
B
And
now
the
definition
of
that
has
been
well,
it's
more
precise
right
now,
it's
defined
more
or
less
as
an
actual
Act
of
sending
something
over
the
wire.
B
B
I
mean
we
should
do
that
technically
for
all
phdp.
Let's
hear
about
the
others.
E
E
When
we
were
when
I
was
seeing
errors
happen
at
the
network
level
that
wasn't
being
captured
in
the
regular
spans
and
so
I
think,
specifically,
especially
with
some
of
the
Neti
stuff,
where
it's
a
little
more
a
little
bit
more
async
and
an
exception
isn't
thrown
necessarily
so
yeah
I
I
think
that
having
a
connect
error
is
useful,
if
only
to
be
able
to
have
a
place,
to
put
a
stack
Trace
to.
B
Yeah
and
Nettie
is
also
an
example
of
HTTP
client
that
doesn't
get
like
all
the
HTTP
request,
details
and
the
connection
phase,
because
because
the
request
happens
after
that,
usually
the
connection
phase,
just
pretty
much
gets
and
and
others
and
that's.
B
D
F
To
further
add
complexity,
I
know
that
several
libraries
have
connection
pools
and
then
do
those
get
also
treated
differently
like
when
the
pool
is
exhausted,
or
you
know
or
when
you
just
get
one
out
of
the
pool.
Do
you
do
you
see
a
connection
span
there
or
you
don't
like?
If
the
connections
do
you
go
ahead,
we.
B
We
have
pretty
detailed,
instrumentation
I
mean.
B
A
pretty
detailed
instrumentation
when
it
comes
to
like
this
like
connection
level
and
that's
more
government
things
and
usually
I
I'm,
like
95
percent,
sure
that
it
works
and
why
but
I
think
it
only
creates
like
the
connect
expense
when
actual
new
connection
is
made.
So
if
you're
using
a
connection
tool
and
you're
like
taking
connections
from
the
pool
and
that
you
you
don't,
you
won't
get
the
new
new
spans.
But
if
a
new
one
is
created,
then
yeah.
F
Which
I
follow
that?
That
makes
a
lot
of
sense.
Logically
I'm
wondering
what
the
user
experience
is
like
and
whether
or
not
there's
a
potential
for
users
to
be
tripped
up
by
that
they
look
at
span
one
and
they
see
a
connection
phase
and
then
the
client
span
they
look
at
Trace,
two
or
whatever,
and
they
don't
see
that
connection
span.
They're
wondering
why
yeah
because
it's
inconsistent
I
mean
and
and
yes,
yes,
it
is
I
guess
is
the
answer.
B
I
mean
and
there's
kind
of
reason
behind
it
anyway
the
reactor
and
that
the
instrumentation
is
also
kind
of
interesting,
because
not
only
the
sculpture,
like
the
actual
connection
and
suddenly
the
connection
phase.
But
it
also
has
separate
spans
for
us
to
sell
handshake
and
DNS
resolution
which
we
might
or
might
not
want
to
do.
At
some
point.
D
Yeah
from
I
mean
if
somebody's
using
raw
Nettie
I
mean
I,
think
they're
kind
of
gonna
get
what
we
can
instrument.
But
if
somebody's
using
a
real
HTTP
client
I
feel
like
every.
D
We
should
definitely
matesh
bring
this.
If
you
want
to
create
a
aspect
issue,
I
can
add
it
to
the
HTTP
semantic
stability
project
board,
I'll.
B
Do
that
tomorrow
cool
but
yeah?
That's
that's
one
of
the,
like
the
probably
the
most
major
issues
that
I
ran
into,
but
yeah.
So
I
I
don't
disagree
with
you.
I
mean
it
makes
sense
for
the
user
to
just
see
HTTP
client
spam
because
who
are
they
using
an
HTTP
client
right?
So
it's
kind
of
obvious
that
you
can
see
like
HTTP
get
and
would
fail
with
some
connection
thing.
A
D
B
Yeah
so
and
anyway,
like
I,
would
like
for
it
to
be
consistent
across,
like
all
HD
clients.
So
if,
if
we
decide
that
we
should
use
an
HTTP
client,
a
HTTP
span
for
connection
failures,
then
let's
do
this
like
everywhere
and
well.
B
We
should
do
something
about
the
aforementioned
reactivenet
instrumentation,
which
right
now
it
includes,
like
all
the
connection
and
stuff
inside,
like
as
children
of
the
HTTP
span,
which
is
I,
think
not
exactly
correct
according
to
the
new
semantic
conventions,
because,
like
I,
these
things
happen
before
you
send
them
HTTP
request
right,
so
they
shouldn't
be
children
of
an
HTTP
request,
but
yeah.
That's.
We
have
to
like
clean
this
up.
D
And
I
am
curious.
One
of
the
things
I
wanted
to
ask
the
for
the
HTTP
semantic
convention
group
is,
you
know
they
could,
because
the
retry
spec
could
be
very
hard
or
impossible
really
to
implement
you.
G
D
Cases
if
that
would
mean
that
that
instrumentation
is
not
compliant
yeah
and
if
so,
you
know
can,
should
we
soften
the
language
in
the
specification
around
how
retries
are
modeled
and
say
this
is
the
ideal
case,
but
this
is
also
acceptable.
D
B
So
I
think
it
should
be
like
optional
recommended,
but
not
necessarily
is
very
hard
to
implement
or
impossible
thing,
but
we
have
like
30
around
30,
different
HTTP,
client
instrumentations,
and
it's
a
rough
guess,
but
I
think
that
we
will
maybe
be
able
to
implement
the
recent
spec
in
like
half
of
them.
D
G
G
B
You
mean
the
retry
recent
counter
or
connection
yeah
counter
yeah.
It's
it's
a
lot
of
work,
but
that's
true.
D
C
D
Thanks
for
trying
that
out,
because
that
is
actually
a
big,
the
retry
spec
is
I'm,
not
sure.
If
there's
any
prototyping
has
been
done,
I'll
have
to
ask
Lynn
Miller.
Maybe
you
should
prototyped
it
in
the.net.
B
Like
to
end
the
discussion
in
a
good
note,
I
think
it
is
super
valuable
for
cases
like
redirections
authorization,
so
recents
that
happen
like
from
anything
other
than
connection
failure.
It
does
makes
things
better.
A
D
We
ran
into
an
interesting
problem
which,
with
are,
can
Bean
GMX
metric
configuration,
which
is
also
an
issue
I
believe
in
our
jmx
metric
gatherer.
Here
metric.
A
D
Yeah
so,
for
example,
this
is
how
we're
mapping
right
the
M
being
and
then
map
this
nested
attribute
to
this
metric
name.
D
D
F
D
So
I
think
when
we
are
in
this
jmx
metrics
implementation,
I
think
this
gets
mapped
to
the
yaml,
and
then
this
gets
broken
down
into
its
components.
And
then,
when
we
do
the
metric
collection,
we
each
time
each
minute
interval.
F
F
Mean
yeah
there's
no
end.
C
It
was
done
on
old,
steampunk
computers,
originally.
D
So
obviously
that
is
not
enforced.
If,
given
that
our
customer
has
this
in
practice,
but
that
is
something
I'm
going
to
research
that.
D
All
right,
well,
don't
want
to
make
my
problem
all
of
your
all's
problem,
but
I
will
I,
will
post
an
issue
and
probably
tag
Peter
on
it,
see
what
he
thinks
also.
F
If
that,
if
that
yaml
format
required
like,
if
it
didn't
imply
a
structure,
if
you,
if
you
required
the
yaml
to
to
spell
everything
out
in
layers
right
so
rather
than
tagging,
on
dot
used
there,
if
you
required
that
to
be
like
a
child
and
you
require
dot
Max
to
be
a
child,
both
of
those
would
be
underneath
Heap
memory
usage.
Does
that
help
at
all.
D
B
B
E
D
D
B
D
D
I'm,
assuming
what
this
means
is
I
mean
because
there
is
certainly
you
can
use
the
Java
agent
on
in
Tomcat,
but
I
am
guessing
what
this
means
is
the
like
static,
instrumentation
of
or
ahead
of
time,
instrumentation
of
the
war
file
instrumenting
the
classes
inside
the
war
file,
which
is
there's
a
POC
in
the
contrib
repo
I,
should
link
to
that
here.
Just
in
case
that
whoever
added
that
checks,
the
notes
later.
D
G
Well,
I
I
can
see
a
few
things
that
might
go
wrong.
I,
don't
think
using
the
the
agents
will
work
very
well
on
these
because
well
on
a
on
a
on
a
container,
you
might
have
multiple
War
files
deployed
and
the
weather
container.
What
the
container
does
is.
It
creates
kind
of
a
curated
class
loader
for
each
one
of
those
War
files,
which
is
a
different
application.
They
can
leave
on
the
same
application
server
independently
and
the
server
will
manage
the
resources
for
all
of
them.
G
F
So
I
correct
me
if
I'm
wrong,
but
I
think
that
if
you
deploy
multiple
War
files-
and
hopefully
other
people
have
experience
with
this
well,
I
think
I
think
that
that
motor
operation
is
has
kind
of
fallen
out
of
fashion.
You
know
that
was
like
all
the
rage
in
the
early
2000s.
Maybe,
but
mostly
people
are
deploying
like
one
application
per
VM
these
days,
but
if
you
were
to
deploy
multiple
applications
in
a
VM,
whether
it
be
through
Wars
or
ears
or
whatever
I
think
that
they
all
get
the
same
resource.
F
D
Yeah
so
foreign.
F
D
Just
to
and
to
kind
of
give
some
context
on
the
we
do
have
many
customers
running
multiple
apps
in
like
Tomcat.
You
know
whether
it's
from
you
know,
Legacy
stuff
that
they've
had
and
so
to
add
to
deal
with
that
multiple,
like
single
resource.
D
F
Did
have
an
action
item
from
last
time
to
see
about
re-running,
Dynamic
tests
and
IntelliJ
and
I've
I've
sat
with
our
HTTP
tests
a
lot
in
the
last
week
and
I
could
not
find
a
way
to
rerun
a
single
Dynamic
test
and
I.
Think
I'm,
not
the
only
person
to
have
asked
for
this
feature
in
IntelliJ,
but
it's
also
I
can
imagine
quite
complicated
to
implement
because
the
conditions
under
which
a
dynamic
test
get
created
or
not
could
be
arbitrarily
complex
right.
F
It
could
be
based
on
the
the
second
of
the
minute,
if
you
so
choose,
which
is
ridiculous
but
point
being
there's
no
easy
way
to
rerun
a
dynamic
test.
You
would
think
that
they
could
they
IntelliJ
could
have
just
like
stored
all
the
context
and
just
would
allow
you
to
like
re-trigger
the
entry
point,
but
I
could
find
no
way
of
doing
it.
You
have
to
run
the
entire
test
again.
F
So
if
that's
deal
breaker,
then
you
know
that
it's
a
bummer
I
also
spent
some
time
looking
at
junip
5
test
templates,
which
are
not
really
what
I
want
I'm
sure,
they're
I'm
sure
they're
very
useful.
For
some
cases,
but
they
sort
of
invert.
F
The
thing
like
you
can
declare
a
test
template
in
junit,
but
it's
method
level
only
and
the
providers
of
the
employ
the
pr
the
execution
contexts
have
to
be
provided
at
that
same
method,
and
so
it's
like
you
can't
you
couldn't
just
publish
those
in
a
library
and
reuse
them
arbitrarily
across
projects.
You
would
have
to
know
all
of
the
execution
contexts
at
the
point.
You
define
the
method
if
that
makes
sense,
so
you
can't
it
assumes
like
a
comprehensive,
like
singular.