►
From YouTube: 2022-10-27 meeting
Description
cncf-opentelemetry meeting-2's Personal Meeting Room
A
B
B
Yeah
sorry,
my
stuff
was
my
explanations:
were
somewhat
confusing,
I,
don't
know.
If
you
remember,
we
were
in
this.
My
co-worker
and
I
were
in
in
the
open
bottom
tree.
Let's
search
black
like
probably
a
year
and
a
half
ago,
working
on
this
lingerie
I
mean
I.
Think
we
were
talking.
His
name
is
sax.
C
Well,
it's
just
every
Sig,
which
is
like
a
working
group
within
open
Telemetry
has
mean
at
some
some
periodic.
We
do
it
once
a
week,
but
it's
usually
we
don't
there's
not
much
to
talk
about
not
many
people
join,
because,
especially
because
we
have
the
earling
foundation
with
the
observability
working
group
where
we
meet
once
a
month
and
that's
where
people
really
join
and
a
lot
of
discussion
happens.
So
all.
B
A
C
And
so
I
mentioned
to
two
of
the
people
that
are
working
on
that
to
drop
by
if
they
want
to
move
that
forward,
I
don't
know
if
they
will,
but
okay.
D
Hi
hi
Tristan
I
work
with
Oliver,
so
he
invited
me
to
jump
onto
the
call.
C
Nice
nice
background.
Oh.
C
B
B
C
B
Exciting
we're
we're
a
bunch
of
erlang
dudes
over
here,
so
I've
done,
I've
tried
sort
of
sleuthing
up
until
on
a
tree
or
like
not
sure
how
successful
I've
been.
B
Yeah
I
think
it
was
I
think
it
was
the
RC
to
the
most
recent,
but
we
did
increment
to
the
1.0,
but
I
didn't
do
a
great
I
didn't
really
test
much
when
I
did
that
so
I'm,
but
I'm
yeah
I'm,
pretty
confident
it
was
the
RC
the
change
from
the
RC
that
you
stopped.
Seeing
that.
C
B
A
B
B
Okay,
let
me
see
if
I
can
share
here
all
right.
You
see
that.
C
B
B
B
Those
are
the
primary
there's.
Basically,
two
concerns
with
it
like
two
things.
We
wanted
to
do
as
a
library,
and
one
of
them
is.
The
thing
is
what
we
talked
about
with,
like
ending
spans
whenever
there's
like
a
process
exit
or
something
sort
of
unexpected,
because
when
we
first
started
using
open
Telemetry,
we
were
just
sort
of
like
losing
those
spins
and
we
were
trying
to
use
open
Telemetry
to
measure
like
do
like
load
tests
and
performance
performance
testing,
so
that
became
somewhat
problematic,
and
so
that
was
what
that
logger
metadata
stuff.
B
There's
really
only
two.
Also,
this
whole
library
and
the
one
of
them
is
the
logger
and
whose
primary
responsibility
is
to
track
the
current
open,
Telemetry
spans
in
the
metadata
structure
of
the
logger
and
sort
of
it
keeps
track
of
them
so
that
when
it
receives
like
a
exit,
we
can
like
end
them
and
make
sure
that
they
get
reported,
and
then
the
other
file
is
this
Handler,
which
does
interact
with
the
logger
as
you
saw.
But
for
the
most
part
the
goal
of
this
was
to
add
some
light.
B
View
tracing,
and
so
our
ideal
Trace
would
look
like
essentially
what
that
photo
showed.
It's
like
double.
A
B
Again,
just
so,
you
can
see
it
do
we
have
the
likes.
Phoenix
I
think
this
actually
is
coming
from
the
Phoenix
I'm,
not
100
sure
about
this,
but
I
think
it's
coming
from
the
open,
2003
Phoenix
Library.
You
know
at
least
the
initial
yet
could
be
wrong
about
that,
but
then
having
these
sort
of
this
nice
like
trace
of
the
live
view,
life
cycle
from
the
front
end
and
then
back
to
like
even
the
handle
events
that
occurred
after
the
live.
B
Socket
connection
happens,
so
that
was
sort
of
our
goal
with
this
and
the
way
we
went
about
achieving
that
was
sort
of
I
mean
it
still
feels
hacky
at
the
time
right
now,
so
it's
very
possible
that
we're
just
like
have
a
wrong
vacation
somewhere
of
like
maybe
one
of
the
older
apis
or
or
that
we
were
relying
on
something
that
wasn't
legit,
I,
guess:
I
sort
of
walk
through
more
specific
areas
in
there,
but
any
like
sort
of
questions.
Yeah.
C
From
that
Trace
image
is,
are
what
you
see
now
that
every
single
one
of
those
is
its
own
Trace.
B
Not
every
single
one-
and
this
is
where
it
starts
getting
interesting,
I,
think,
because
so
we
are
seeing
that
the
initial
live
spam
comes
through
along
with
the
so
one
other
thing
you
should
know
is
we
use
the
propagation
like
the
propagation
module
to
make
sure
that
the
front
end
has
the
right,
Trace,
ID
and
Trace.
We
visually
propagate
the
trace,
ID
and
the
spaniel
digital
front
end
and
the
front
end
picks
that
up
and.
A
B
B
This
is
what's
happening
now,
but
the
ideal
of
this,
where
we
have
sort
of
like
the
same
basically
that
the
second
Mount
and
that
subsequent
handle
events
have
the
same
parent
ID
like
spans
parent
span,
which
is
considered
I,
guess
the
live,
signing
the
next
and
the
live
socket.
Connect
is
sort
of
underneath
this
top
level
Trace.
C
B
B
B
Okay,
yeah
I
noticed
that
in
we
only
seem
to
see
the
live,
capitalized
events,
which
is
on
one
of
our
events
and
I,
can
pop
it
back
to
that.
Let's
see
when
you
create
our
first
pair
of
the
contents,
that's.
B
I
believe
it
does,
you
can
actually
double
check
this
one
of
these
tabs
open.
B
So
span
and
we
wanted
to
see
if
initial.
B
Then
I'll
make
it
I
think
we
were
getting
them,
but
you'll
see
that
they're
kind
of
like
on
their
own
in
their
own
Trace.
Okay,
so.
B
Seem
to
be
getting
nested,
but
it
does
have
a
child.
It
has
these.
This
Ecto
span
underneath
it
which
I
don't
exactly
know
how
that
works.
B
B
B
Yeah
I
know
this
is
a
lot
there's
a
lot
going
on,
that's
not
until
it
might
be
too
much
to
sort
of
do
in
this.
In
the
context
of
this
meeting
can.
B
B
I,
don't
know-
maybe
maybe
not,
maybe
not,
but
we
we
basically
like
store
the
parents
context
temporarily
so
that
we
can
like
get
it
later
on.
C
Do
you
really
need
because
the
well
I
guess
since
you
used
start
where
you
set
current
spam
and
that
is
into
the
processed
dictionary,
so
you
shouldn't
need
to
store
it
again
in
the
process.
Dictionary.
B
C
C
B
That's
what
I've
been
trying
to
understand-
and
this
is
like
again
like
yeah
I'm,
sorry
I'm
working
from
sort
of
scraps
here
so
like
I,
don't
entirely
understand
why
I
mean
just
immediately
end
the
stand
after
starting
it.
It
seems
that
seems.
C
Maybe
the
end
span
I'm,
not
sure
what
the
purpose
I
mean.
I
guess.
Maybe
it's
ended
because
he
doesn't
want
the
entire
live
view.
Mount,
as
a
giant
span,
I
mean
I.
Think
that's
some
people
like
that
some
people
don't.
C
B
B
C
C
You
shouldn't
need
to
get
it
at
all:
okay,
so
wherever
we
but
you're
propagating
from
the
JavaScript
to
the
back
end
to
get
the
parent,
and
then
that
puts
it
into
the
process
dictionary
when
you
extract
it.
B
A
C
So
when
that's
called
the
parent
will
be
set,
and
then
you
should
be
good
unless
you
pass
a
parent.
If
you
pass
a
parent,
it
won't
use
the
process
dictionary.
But
if
you
don't
pass
a
parent
it
will
so
you
should
be
good
to
just
call
without
a
parent.
After
that.
B
C
If
yeah,
if
the,
if
extracting
from
the
what
JavaScript
sent
works
so
because
that
could
be
broken,
yeah.
B
B
Yeah
and
the
JavaScript
sides
we
also
so
the
thing
I'm
confused
about.
We
also
have
we
render
it
as
a
meta
tag
in
our
the
head
of
our
document,
so
I'm
not
sure
between
the
plugin,
and
this
view,
logic
where
we
like
are
adding
the
current
context:
Trace
grants
to
The
Meta
tag.
This
is
where
this
is,
where
I
believe
we
like
take
the
the
trace
parent
header
stuff
and
send
it
back
up
to
the
live
socket.
B
So
in
it's
kind
of
confusing,
because
the
the
user
of
this
library
is
meant
to
sort
of
do
that
work.
So
we
tell
them
hey
call
this
meta
tags
function
in
your
view,
so
that
it's
available
somewhere
in
your
Dom
and
then,
when
you
wire
it
up
when
you
wire
up
this
Library,
do
these
like
call
a
knit
Tracer
and
then
past
the
span,
our
library,
I?
B
B
B
C
C
B
C
B
B
C
Yeah
good
to
have
in
a
library
somewhere,
but.
B
C
B
B
C
Ahead
and
what
we
changed
and
how
create
parent
passes
to
create
child
I
would
get
rid
of
passing
the
parent
to
create
child
and
just
let
it
use
the
process
dictionary
and
see
what
right
and
then
we
can
go
from
there.
B
C
B
Macro
yeah
that
one's
right
I'll
get
a
little
mixed
up
there
too.
Okay,
so
then
we'll
just
need
to
make
it
so
that
wherever
we
call
create
Childs
child's
fan,
you
don't
ask
the
parent
context
anymore.