►
From YouTube: 2022-09-20 meeting
Description
cncf-opentelemetry@cncf.io's Personal Meeting Room
A
A
B
Eden
thanks
for
posting
a
reminder
in
the
slack
Channel
I
think
that's
very
helpful.
B
B
That's
everything
currently
on
the
agenda.
If
you
have
something
else,
you
wanted
to
talk
about,
go
ahead
and
please
add
it
there.
Let's
see
where
we
at
three
minutes
past
the
hour.
B
Okay,
I
think
we
have
Quorum,
so
we
could
probably
just
jump
in
here.
Oh
that's,
not
eight.
A
People,
okay,.
B
Well,
anyways
I
think
we're
all
set
so
welcome
everyone
thanks
for
joining
I
guess.
The
first
thing
on
the
agenda
is
a
demo.
I've
got
the
compile
time,
Auto
instrumentation
first
but
I
didn't
know.
If
that's
Chris
like
are
you
ready
to
share
that.
C
B
I'll,
stop
sharing
and
I'll
hand
it
off
to
you
and
we
can.
We
can
explore
the
proposed
solution
here.
C
Yeah,
okay,
so
I
will
shut
the
screen.
Do
you
see
it.
A
C
C
A
project
and
I
will
show
you
how
it
works.
So
so
the
the
things
that
you
are
seeing
on
the
screen
is
very
simple
projects,
so
we
have
a
mind
function
here,
which
calls
a
process
and
process
calls
processing
function.
So
in
order
in
order
to
instrument
that
my
first
goal
was
to
have
something
that
will
instrument
the
whole
call
graph.
Of
course,
a
user
can
select
specific
functions
that
you
want
that
he
wants
to
to
instrument.
C
So
in
order
to
instrument
that
we
have
to
add
one
additional
code
from
the
kind
of
random
library
that
I
implemented.
It's
very
simple
one
and
the
call
is
called
Auto
entry
point
now.
It
see
that,
because
the
tool
in
the
first
pass
it
searches
for
such
call
to
know
where
it
should
start
instrumenting.
So
the
in
this
case,
our
main
function
will
be
our
entry
point
of
the
instrumentation
and
that's
why
we
have
this
call
here,
but
this
it
doesn't
need
to
be
that
way.
C
We
cannot
switch
to
the
command
line
or
we
can
read,
read
this
from
from
the
configuration
file.
So
in
this
case,
as
we
would
like
to
start
from
the
main
function,
we
should
pass
something
like
that
because
then
the
main
is
in
is
in
this
package
now,
when
we
can
invoke
this
tool
and
pass
some
switches,
one
of
them,
the
most
important
is
inject
and
we
have
to
tell
where
our
project
is
and
also
a
kind
of
white
card
which
packages
we
would
like
to
instrument.
C
And
this
we'll
call
this
tool
and
just
few
passes
and
as
you
can
see,
this
is
a
result.
So,
in
the
main
function
we
have
some
initialization
stuff
and
then
we
create
a
spawn
for
the
main
and
then,
as
you
can
see,
there
are
also
other
response
created
for
other
functions
and
also
one
additional
parameter
is
is
update,
which
is
a
context
to
to
have
a
context.
Propagation
now
I
can
tell
you
more
what
are
the
passes
in
in
this
tool.
C
So
basically
it
was,
as
I
said,
it
works
as
a
compiler,
so
first
it
searches
for
this
entry
point.
Then
it
tries
to
build
a
kind
of
call
graph
yeah,
so
it
it
traverses
all
all
function,
declarations
and
and
all
functions
call
function,
calls
and
try
to
build
this
call
graph
and
then
it
it
is
adding
this
open,
Telemetry
calls
and
at
the
end
it
is
doing
context
propagation.
So
it
adds
this
additional
context,
parameter
into
function,
declarations
and
also
into
function
calls
and
now
any
questions
so
far.
C
C
C
C
For
me,
it's
a
distributed
tracing
so
the
so
so
this
this
is
something
that
we,
you
have
to
pass
a
context
between
different
processes
and
so
I
I
spent
a
few
hours
this
week
and
I
added
in
initial
support
for
http,
so
I
I
can
show
you
how
how
it
looks
like
so
we
have
a
client.
This
is
basically
this
the
same,
almost
the
same
code
as
we
have
I
think
here.
C
C
So,
as
you
can
see,
it
was
also
added
this
initialization
stuck
and
then
we
also
creating
spawn
for
Main.
We
are
changing
client,
HTTP
client,
with
additional
transport.
We
are
passing
a
new
transport
there
and
here
do
in
this
Anonymous
function.
We
generated
a
new
spawn
so
so
generally
that,
basically
for
the
client-
and
it's
known
as
the
as
this
one,
so
it's
a
one-to-one
correspondence
and
for
server
I
can
show
you
how
it
works
as
well.
C
So
for
Server
we
we
need
some.
We
need
to
generate
some
different
codes,
so
we
have
to
take
context
from
the
request.
We
have
to
call
response
from
Context
and
then
pass
it
to
the
processes
it
was
in
this
basic
exam,
so
generally,
adding
support
for
libraries
is,
of
course
possible,
and
it's
not
very
different
from
from
what
I
did
for
at
the
beginning
and
I
would
say
that
it's
even
it's
it's.
C
This
call
calls
from
from
this
from
this
implementation,
and
it
generates
code
based
on
on
this
apis,
but
this
it
works
in
in
similar
ways
as
any
other
compiler
I
would
say
so
so
we
always
have
some
kind
of
library
that
we
we
have
to
use
and
we
link
them
to
the
to
build
the
whole
process
and
I
would
even
say
that
supporting
libraries
is
is
event
simpler,
that
what
I
was
doing
for
this.
C
Passing,
let's
say
a
degenerating
spans
for
for
all
functions
due
to
the
fact
that
there
are,
there
are
limited
number
of
calls
that
the
library
has.
C
So
that's
basically
what
I
wanted
to
show
you
and
now
do
you
have
any
questions
regarding
this
support
of
libraries?
Of
course,
what
what
I
can
say
about
trades
of
trade-offs,
because
I
haven't
mentioned
that.
E
C
So,
first
of
all,
we
need
to
have
an
access
to
the
source
source
code,
so
we
we
cannot
use
this
tool
if
we
don't
have
an
access
so
and
that's
an
advantage,
but
it
can
be
also
a
disadvantaged
for
someone
that
wants
to
instrument
something
that
we
don't
have
a
code
access
other
than
that
it's
it
works
basically
in
very
similar
way
as
binary
instrumentation.
So
we
are
changing
in.
In
this
case
we
are
changing
code,
but
binary
instrumentation
chain
changes,
byte
code
so
and
it's
executed
by
VM
for
Native
programs.
C
We
we
cannot
do
that
easily.
So.
C
C
Yeah
so
debugging,
as
you
can
see,
when
you
generate
this
code,
you
can
you
can
debug
the
code
before
you.
You
commit
the
changes.
C
Right
so
for
now,
when
I
will
run
it
another
time,
it
will
generate
the
same
code
many
times
but
as
I
said,
I
can
fix
that
easily.
D
D
C
So
I'm
currently
testing
it
on
a
large,
larger
code
basis,
for
one
of
my
goal
is
to
instrument
open
Telemetry
collector
itself,
but
there
are
still
some
issues
that
the
end
time
fixing
them
one
by
one.
But
as
I
said
last
week,
I
was
mostly
focusing
on
on
that
HTTP
instrumentation,
at
least
POC
of
that
to
to
check
if
we
can
do
that
and
yeah,
but
but
I'm
actively
working
on
on
testing
it
on
large
code
bases.
F
I
was
asking
about
the
bargain,
because
I,
don't
I,
assumed
that
the
use
case
or
how
it
will
be
used
is
that
the
generated
code
will
be
not
checked
in
right.
That
was
my
guess
when
I
first
saw
it,
but
if
it
will
be
not
checking,
then
I
think
there
should
be
some
means,
like
I.
Do
some
debugging
simple
change
in
the
binary
itself
that
it
will
allow
debugging
without
having
the
source
code?
F
Otherwise,
if
we
check
in
the
code,
in
my
opinion,
it's
not
automatic
instrumentation
is
simply
a
tool
to
generate
code
for
manual
instrumentation.
That's
how
I
see
it.
Okay,.
A
C
As
you
said,
we
can
I,
don't
know,
add
some
debugging
symbols
and
then
it
will
be
possible
to
to
debug
it.
If
we
don't
have,
you
know,
checking
this
code.
B
So
when
I'm
hearing
Robert
is
just
want
to
make
sure
I
understand
you
correctly,
because
I
like
this
is
reminded
me
of
my
C
C
plus
plus
days,
where
you're
talking
about
literally
having
the
binaries
be
shipped
with
like
a
debug,
you
know,
companion
that
would
allow
that
debug
code
when
it's
run
to
do
the
instrumentation
yeah,
so
I
think
the
key
is
to
not
like
I,
think
terms
are
really
important
here.
Right
and
I.
B
Think
you're
right,
like
maybe
saying
that
this
is
automation
when
it's
instrumenting
the
source
may
not
be
accurate,
but
I
just
want
to
point
out
that,
like
the
at
the
end
of
the
day
like
what
we
call,
it
is
important,
but
it's
also
important
that
we're
providing
value
to
the
users
right
and
I
think
that,
like
this
is
I
I
would
I
would
argue
strongly
that
this
is
a
good
thing
where
this
kind
of
project
would
be
contained,
because
I
think
that
this
is
again
like
what
we
talked
about
last
or
two
weeks
ago
was
like
this.
B
The
goal
of
this
thing
is
essentially
trying
to
take
that
barrier
to
entry
to
instrumenting
new
users.
New
to
open,
Telemetry
and
get
them
up
and
running
in
the
shortest
time
as
possible
and
I
see.
This
is
a
really
positive
solution,
especially
for
those
that
don't
like
spooky
magic
happening
underneath
the
system
that
they
can't
see
directly,
whether
that's
through
a
debug
binary,
whether
that's
through
the
evpf,
and
they
want
to
actually
see
what's
actually
happening,
I'm,
not
saying
that
those
are
actually
spooky
and
that
we
couldn't
provide
guarantees
around
them.
B
But
I
just
want
to
say,
like
you
know,
this
might
fit
a
particular
user
class.
That's
really
like
important
to
fit
as
well
is
like
that
user
class
that
just
wants
to
essentially
run
it
and
then
maybe
even
start
modifying
it.
So
I
I
like
that
idea
of
having
a
debug
binary
I've,
never
seen
something
like
that
and
go
it's.
It's
actually
kind
of
hard
to
not
get
nerd
sniped
on
this
and
go
find
out
about
it.
B
But
I
I
definitely
want
to
say
that
like
if
we
do
that,
I
would
I
want
to
do
that.
In
addition
to
this
as
well,
I
think
that
there's
there's
value
in
both
of
those
things
personally.
A
This
is
making
me
want
integration
with
like
the
build
system.
So
basso
has
support,
for
you
know:
sophisticated
pipelines
of
code
generation
that
you
could
then
compile,
and
then
it
should
be
easy
to
add
it's
just
sort
of
like
taking
an
existing,
build
turn
on,
auto
instrumentation
seems
possible,
but
I
don't
think
you
would
want
to
do
that
without
build
support.
B
Yeah
I
think
that
the
thing
that
really
stands
out
to
me
that
about
this
is
just
like
that:
that
user
value
that
comes
off
off
the
off
the
get-go
and
I
think
that
there's
a
lot
of
questions
about
how
this
can
be
extended
in
the
future
as
to
like
you
know,
can
the
support
libraries?
How
can
this
get
cleaned
up?
How
can
this
get
annotated,
but
I
think
that
the
key
question
that's
going
to
really
be
important
to
get
this
off
the
ground?
B
Is
that
user
interface
right
off
the
bat
and
like
how
that
shows
up
in
user
code
and
making
sure
that
that's
right
and
making
sure
it's
extensible
in
the
way
that
we
want
to
go
but
like
making
sure
that
you
essentially
can
say
to
a
user
like
you
know,
I
think
we
talked
about
this,
the
the
entry
point
you
were
talking
about
President,
the
you
know
is
is
that
is
that
part
of
where
you
add
that
function
into
the
code,
so
the
tool
can
find
it
the
way
we
want
to
go,
and
you
want
to
go
to
a
comment.
B
Do
you
want
to
one
of
the
other
things
I
was
thinking
is:
do
you
want
to
pass
like
the
function
name
into
the
CLI
like
that,
could
be
something
as
well
as
as
the
entry
point,
how
that
looks
and
make
sure
that
it's
not
like
you
know
if
a
context
is
already
there
like
making
sure
that
it's
not
overriding
it
and
make
sure
that's
a
really
good
I
think
solid
user
experience
from
the
get-go
is
going
to
make
this
I
think
the
most
important
part
as
a
launching
point,
I
think
the
extensibility
into
these
instrumentation
libraries
is
important
for
this
POC,
because
you
can
show
that
it
can
be
done,
but
I
don't
think
in
the
like
in
the
the
grand
scheme
of
like
how
we
want
to
build
this
like
that,
would
be
as
important
right
off
the
start
and
and
I'm
wondering
if
that's
everyone
else's
opinion
as
well.
A
My
suggestion,
like
my
one
thing
that
I
would
take
away
from
this,
is
the
item.
Potency
is
probably
going
to
be
the
biggest
user
experience,
stumbling
block
that
people
might
see
just
people
running
it
twice
and
then
messing
up
everything,
so
I
wouldn't
think
that
might
be
the
like.
That's
probably
where
I
would
spend
a
good
like
50
of
my
time,
at
least
on
this
but
yeah-
and
this
is
super,
exciting
and
I-
think
good
work.
D
B
B
Yeah
because
I
think
I
think
at
this
point
I
wanted
to
you
know
it's
so
easy
to
just
start
building
out
project
boards
for
this.
But
I
want
to
make
sure
that,
like
we,
we
focus
on
like
the
goal
of
having
a
you
know
a
singular
direction
for
for
at
least
the
initial
kickoff,
and
so
to
do
that.
Let's
jump
over
to
Eden
and
we're
gonna
do
a
little
demo
of
the
runtime
auto
transportation
with
evpf.
E
Yeah
sure
so
actually
prepared
a
couple
of
slides
yeah,
so
we
start
with
the
demo
and
after
that,
I
will
try
to
talk
a
little
bit
about
EVPs.
I
guess
not.
Everyone
here
is
familiar
with
what
is
gdpf,
we'll
take
a
really
high
level
architecture
about
how
all
of
this
works
and
I
will
end
with
some
project
status.
E
So,
let's
start
with
the
demo,
so
I
have
here
I'm
going
on
this
Emoji
photo
thing
from
buoyant,
which
is
basically
like
a
three
microservices
three
go
microservices
application
like
and
I.
Have
it
here
deployed
alongside
an
empty
agar
instance
that
I
configured
to
receive
LPL
and
those
just
to
be
clear
or
regular
job
applications
without
any
open,
Telemetry,
SDK
or
any
instrumentation
at
all?
And
basically
all
I
have
to
do
in
order
to
show
you
the
Jager
with
is
empty
and
basically
all
I
have
to
do
for
instrumenting.
E
Yeah
and
now
all
we
have
to
do
is,
let's
generate
some
profit.
Let's
go
into
this
application.
It's
like
this.
You
vote
for
your
favorite
emoji
thing.
So
let's
do
a
couple
of
boats,
in
the
view
the
leaderboard
and
now
hopefully,
if
we
will
go
to
Diego,
we
should
see
traces,
just
as
you
would
expect.
Let's
explore
one
of
those
traces,
for
example,
this
slash
World
API
and
that's.
E
The
first
thing
you
can
see
here
is
that
actually
the
version
that
I'm
showing
you,
the
of
the
automatic
instrumentation,
is
a
little
bit
newer.
The
one
that
you're
going
to
find
in
GitHub
I
hope
to
release
it
in
the
next
yeah,
probably
two
days,
and
so
the
first
thing
you
can
see
that
there
is
context
propagation,
also
between
different
libraries
and
the
same
project.
E
So
actually
the
stressed
out
with
some
HTTP
request,
it's
an
HTTP
server
and
as
a
response
it
does
two
grpc
requests
to
to
the
downstream
services
and
all
the
different
spans
that
you
see
here
have
been
trying
to
follow
the
Cinematic
conventions
and
be
according
other
than
specification.
The
context
propagation
itself
is
in
the
w3c
format.
So
it
should
work
with
any
other
automatic
instrumentation
or
any
other
instrumentation
by
open
Telemetry
that
supports
this
and
yeah.
You
can
see
like
all
the
different
attributes
that
you
would
expect.
E
Another
cool
thing
that
you
can
see
here
is
that,
because
this
application
is,
is
so
it's
so
simple,
like
the
entire
Trace
just
took
like
five
milliseconds
and
like
I,
think
this
can
a
little
bit
demonstrate
the
low
overhead
that
during
instrumentation
with
evpf
ads
like
if
we
would
try
to
do
it
with,
like
other
Technologies,
like
service
measures
or
Envoy.
E
This
would
itself
like
triple
the
amount
of
of
this
of
this
specific
request,
but
if
it's
super
fast
and
super
low
overhead,
so
like
it's
like
nanoseconds
and
of
course
this
supports
like
a
more
complicated
traces.
If
you
go
for
them
to
the
leaderboard
one
which
basically
do
a
for
Loop
for
every
Emoji,
you
can
see
also
the
grpc
requests
are
being
made
and
the
context
propagation.
That
is
also
working
and
again,
those
were
just
like
regular
game
applications.
But
then
you
go
version
out
there
yeah.
So
this
was
the
devil.
B
E
Yeah
sure
so,
basically,
one
of
the
arguments
the
instrumentation
process
receives
is
that
all
PLP
backend
like
where
we
want
to
receive
your
Tracer
I,
already
have
here
an
empty
instance
of
Jager
deployed
so
I,
just
like
passed
in
Jaeger
with
part
like
with
the
European
people.
B
E
Controller,
so
yeah
I
will
have
a
little
bit
of
a
high
level
architecture,
so
it
would
be
clearer
yeah,
but
just
because
yes,
currently
it
is
deployed
as
a
sidecar.
As
you
can
see
any
any
one
of
those
microservices
have
additional
processes
that
basically
build
experimentation,
but
that's
just
because
it's
an
early
project,
I
I'm
sure
we
will
move
to
to
do
it
like
one
instrumentation
per
node.
It's
called
like
a
demon
set
or
something
like
that.
But
currently
it
is
one
process.
Yes,.
A
A
C
E
Yeah
sure
so,
let's
go
ahead
before
I
show
you
like
a
little
bit
how
it
looks,
let's,
let's
just
make
sure
we
all
know
what
pbpf
is
so
actually,
if
it's
something
really
old,
it's
starting
in
the
90s
there's
a
mechanism
to
like
filter
and
Route
packets
in
the
Linux
operating
system,
but
nowadays
vpf
is
much
more
than
that.
Basically,
besides
the
name,
everything
else
changes
does
the
name
stay.
The
same.
Adpf
nowadays
can
do
much
more
than
just
packet
and
router.
E
Basically,
what
evpf
gives
us
is
the
ability
to
run
sandbox
application
set
box
programs
inside
the
the
kernel
inside
the
operating
system
and
by
sandbox.
That
means
those
are
restricted
application.
You
can't
do
whatever
you
want
and
those
are
usually
these
gdpf
programs.
You
usually
write
them
in
some
subset
of
c
and,
for
example,
you
can't
do
infinite
Loop,
you
can
do
dynamical
location,
you
can
perform
any
Cisco,
so
they
are
very
like
safe
to
run
and
the
the
kernel
make
sure
you
can't
crash
other
processes.
E
You
can
press
the
operating
system,
you're
very
much
isolated
in
your
own
sandbox
EPF
programs.
Beside
me,
loaded
to
the
kernel,
I,
usually
event
base
they're,
usually
triggered
by
an
event
that
happens
in
the
system.
Events
can
be
something
that
happens
in
the
kernel.
You
basically
can
attach
an
ubf
program
to
to
any
function
in
the
kernel.
You
can
also
attach
a
newf
program
to
like
the
network
devices
and
they
do
packet
processing
or
packet
filtering,
which
is
a
little
bit.
E
What
the
original
evpf
thing
did,
and
you
can
also-
and
this
is
like
where
this
project
Pakistan
is-
you
can
also
trigger,
if
you
have
programs
by
events
from
user
functions
and
EPF
is
widely
used
nowadays
by
many
other
projects,
also
in
the
sincere
Simian,
Falcon
final
stop
and
many
others,
and
like
this
concept
of
loading,
they're
restricted,
sandbox
program
into
somewhere
else,
which
runs
it.
It's
not
really
new
today
to
not
something
that
evpf
invented.
It's
something
that
actually
we've
seen
before.
E
If
you
have
a
little
bit
of
like
basic
front-end
background,
like
one
of
the
common
ways
to
explain
evpf,
is
that
like
in
pf
and
Linux,
is
basically
almost
the
same
relation
as
JavaScript
and
the
browser,
if
you
think
about
the
jump
strip
like
put
aside
since
technology,
as
you
usually
can't
read
files
in
JavaScript
open
processes,
so
it
also
have
some
kind
of
sandbox
and
you
load
it
to
the
browser
which
basically
runs
it
and
like
this
is
what
makes
web
pages
be
dynamic
and
so
I
hope
this
was
clearly
have
any
questions
regarding
evpr.
E
This
is
really
like
in
a
nutshell.
So
now
that
we
know
what
is
vpf,
we
can
look
a
little
bit
about
how
this
thing
works.
I
will
start
and
saying
this
is
more
complicated
than
this,
but
I
don't
want
it
to
overwhelm
you
so
like
for
others.
For
this
instrumentation
to
work.
There
are
three
parties
involved.
You
have
the
target
applications
about
the
process.
You
have
the
kernel,
the
operating
system
and
you
basically
have
our
own
process
the
automatic
instrumentation
process.
E
So
everything
starts
by
luckily,
for
us,
the
go
Linker
lives
on
every
go
binary,
something
a
little
bit
like
the
gold.sump
file,
which
basically
lists
which
Go
version
this
binary
was
compiled
with
and
like
the
exact
versions
and
libraries
and
dependencies
that
are
being
used.
So
the
first
things
that
happens
is
the
app
instrumentation
process,
looks
at
the
Target
binary
and
basically
finds
all
the
relevant
dependencies
that
it's
going
to
using
and
the
Go
version
the
compile
this
binary.
E
We
also
have
like
a
little
database
in
this
process,
which
is
like
a
mapping
between
a
library
and
a
version
to
how
we
should
instrument
it
to
the
exact
offset
of
their
of
the
different
parameters
or
the
arguments
in
the
functions
that
we
read
and
this
this
database
is
kept
update,
along
with
any
new,
for
example,
grp
symptoms
and
any
new
Gold
version
those
automatically
to
this
database,
and
now
that
we
have
the
list
of
the
use
dependencies
and
this
database.
That
tells
us
exactly
how
we
should
read
those
libraries.
E
We
basically
have
everything
that
we
need
in
order
to
instrument.
The
libraries
like
this
database
is
what
helps
us
with
being
compatible
with
different
version
of
of
the
instrument,
the
libraries,
so
we
support,
like
very
odd
versions
of
glpc,
where,
like
most
of
the
stock,
look
completely
different
at
what
they
look
today.
All
of
this
is
possible
recording
by
this
mapping.
E
So
the
next
step
is
that
we
are
actually
going
to
load
different
evpf
program
into
the
Linux
kernel.
We
have
a
program
for
any
instrumental
Library,
so
if
our
application
is
using
httpc,
we
will
have
one
for
HTTP
and
one
for
grpc
and
every
one
of
those
evpf
program
is
responsible.
Basically
for
two
things.
It
creates
expensive,
obviously
of
what
happened
inside
of
this
instrument
and
function
and
is
also
responsible
for
context.
Propagation
So,
reading
relevant
headers
writing
relevant
headers.
E
So
that's
like
this
step
and
like
we
said
that
any
evpf
program
is
event
basically
can
receive,
and
you
attach
it
to
one
to
some
Souls.
So
we
also
attached
every
evpf
program
to
the
relevant
functions
inside
the
GoPro.
So
let's
say
we
want
to
instrument
that
the
net
HTTP
Library
will,
for
example,
you
can
attach
it
to
http.get
method.
E
So
once
everything
once
this
is
happening.
Basically,
the
application
runs
as
normal.
The
processor
is
executing
a
GoPro,
and
once
we
hit
a
function
that
have
an
evpf
program
attached
to
it,
the
operating
system
will
automatically
jump
to
our
EDP
program,
and
all
of
this
happens
really
really
fast.
E
Stop
time
stand
time
stamp
in
the
different
arguments,
do
context
propagation
and
return
the
control
back
to
back
to
the
application
when
it
when
it
left
every
one
of
those
programs
have
like
a
little
buffers
of
events
of
spans
is
that
it
and
once
in
a
while,
either
by
a
timeout
or
when
we
reach
a
certain
size,
it
will
send
those
stance
to
our
own
process
where
we
convert
them
from
from,
like
kernel
events
into
the
ltlp
format,
so
we
have
a
translation
functions
and
where,
eventually,
we
actually
use
the
auto
go
SDK
in
order
to
to
create
those
spans
and
send
them
over
to
any
ltlp
compatible
backend,
and
was
that
clear?
C
E
E
Every
version
of
grpc
should
be
automatically
indexed
inside
of
this
developments,
but
if
we
will
have
the
situation
where
it's
a
version
that
is
not
supported,
we
can
choose
either
to
basically
not
instrument
this
library
at
all,
or
we
can
try
and
like
guess
and
take
like
the
most
closed
version
to
it,
that
we
have
inside
of
database.
Usually
there
are
not
many
changes
across
versions
like,
and
we
try
to
instrument
like
a
very
stable
functions
like
that.
E
Okay,
moving
on
so
before
I
finish,
I
would
like
to
make
you
excited
about
EVPs
as
much
as
I.
Do
I
think
that
the
way
that
this
project
uses
is
ABP
app
is
something
that,
like
no
other
project
uses
ebvf
in
the
same
in
the
same
way,
most
of
the
use
cases
we've
seen
until
now
in
Project,
like
psyllium
or
Falco.
E
Basically,
if
you
remember,
ebps
programs
can
be
invoked
by
three
types
of
you
know:
user
events,
kernel
events,
so
network
devices,
so
most
of
the
EPS
applications
that
we've
seen
can
now
are
using
either
the
kernel
events
like
doing
observability
over,
like
how
slow
is
my
hard
drive
and
like
what
is
the
latency
of
the
network
or
something
like
that
and
or
either
do
with
network
stack
like
smarter
routing
of
packets
and
stuff,
like
that,
we
put
a
lot
of
emphasis
about
invoking
EVPs
programs
from
user
functions
and
go
is
a
perfect
language
for
that,
because
everything
comparison
with
me.
E
So
this
person
gives
the
API
in
a
very
unique
way,
and
we
basically
what
you
saw.
Here
We
extended
the
static
binary
from
from
the
kernel
which
something
that
wasn't
really
possible
until
evpr
until
now
and
like
I,
think
that,
in
hindsight,
like
this,
entire
slide
is
my
opinion.
Of
course.
E
Maybe
some
people
will
not
agree
with
that,
but
I
think
that,
like
the
greatest
thing,
the
evpf
gave
us
besides,
like
being
able
to
extend
the
camera
and
extend
do
a
better
Network
stuff
I
think
it
gave
us
the
ability
to
to
basically
to
extend
any
any
binary.
It
can
be
dynamic,
of
course,
and
it
also
be
static
like
the
ones
that
I
just
showed
you
and
yeah
I'm
really
excited
about.
It.
E
I
think
that
if
we
continue
with
the
front-end
analogy
of
JavaScript
and
browsers,
I
think
that
most
of
the
users
that
we've
seen
until
now,
evpf
is
like
using
JavaScript
but
mostly
for
building
like
browser
extensions
like
yeah,
adding
new
capabilities
to
the
browser.
I
think
this
is
a
really
new
use
case
for
VPN.
E
It's
obviously
like
real
dvpf
to
build
something
like
I.
Don't
know
that
helps
the
application
you
can
like
keeps
the
analogy
and
the
compare
it
to
something
like
react,
and
also
personally
that
I'm,
a
huge
believer
in
this
and
I
I
left
my
job
at
Yahoo
to
found
a
company
that
does
exactly
this
and
like
a
mogado
thing,
we
really
believe
in
abpf
in
this
method
like-
and
this
is
like
the
last
slide
like
where
is
this
project
is
so
we
actually
use
this
going
to
rotation.
E
This
is
power
of
our
other
open
source
project.
It's
called
Lobby
glass,
it's
a
control
plane
for
observability.
If
you're
interested
you
can
check
it
out,
but
the
important
thing
is
that
we
assume
that
we
estimated
about
500
users
are
running
distance
from
Indonesia
from
all
different
types
of
metrics
that
we
have
like
Docker,
balls
and
stuff
like
that
regarding
features.
So,
as
I
said,
the
version
that
you
see
here
is
in
your
own
version
compared
to
what
is
in
GitHub.
E
Currently,
this
version
contains
context
propagation,
also
in
process
from
grpc
to
http,
but
also
across
processes
via
the
w3c
format.
One
of
the
of
the
comments
that
is
that
we
got
when
donating
this
project
to
open
Telemetry
was
that
the
previous
version
was
dependent
on
the
govardin
ID,
which
is
something
that
they
go.
Team
does
not
recommend.
So
we
remove
this
dependency
completely.
Now
only
depends
on
the
content
subject,
so
things
that
we
are
currently
working
on
is
the
arm.
E
E
B
When
you
say
you're
going
to
add
you're
working
on
support
for
other
libraries,
is
it
pluggable?
B
How
do
you
add
support
I
guess?
Is
it
like
a
a
different
component
that
you
compiled
yeah.
E
You
just
yeah,
you
have
to
add.
Like
a
new
evpf
program,
you
had
another
C
file
to
the
project
that
we
have.
We
have.
We
already
have
a
lot
of
util
functions.
It
makes
it
really
easy
to,
for
example,
read
the
context,
object
and
the
do
propagation
and
create
span
so
like
the
differences
between
instrumentation
of
different
libraries
is
something
we
try
to
keep
to
minimal,
but
yeah.
It's
basically
adding
another
C
file
and
another
go
find
that
loads.
The
C
file
into
the
camera
yeah.
B
Okay,
is
there
like
a
main
evpf
like
launcher,
go
file
that
essentially
could
could
load
all
of
the
other
ebpf
files.
A
B
E
It's
it's
got
the
loads,
only
the
the
libraries
that
it
found
inside
the
binary.
So
if
you
are
not
using
grpc,
we
will
not
load
the
evpf
program
that
relates
to
grpc.
Thank.
B
You
I
got
you
and
so.
B
F
E
F
D
Thank
you,
I
I
think
the
core
part
of
the
logic
seems
to
be
their
Library
offset.
So
how
are
you
generating
that,
and-
and
also
are
you
when
you
say
donating?
Are
you
donate
that
part
of
the
code
as
well
right.
E
Yeah
sure
yeah,
so
it's
a
long
answer
but
I
try
to
make
it
quick.
Basically,
it
also
relates
to
what
Robert
asked
about
dwarf.
Basically,
we
have
like
a
GitHub.
It's
a
different
project.
It's
called
offset
Striker,
it's
also
open
source.
It's
just
not
under
the
open
Telemetry
organization.
We
can
donate
it
also
if
we
want,
but
basically
what
we
do
is
we
have
some
sort
of
like
GitHub
actions,
it's
lessons
or
to
any
new
version
of
go
a
new
version
of
your
PC
or
any
one
of
the
instrument.
E
The
libraries
that
wants
a
new
version
comes
out.
It
will
actually
automatically
generate
a
go
application,
which
is
is
dependent
which
Imports
the
the
required
Library.
So
it
will
actually
have
like
a
main
file
with
the
import
underscore
grpc
with
the
relevant
version,
and
it
will
compile
with
debug
symbols
with
one
and
once
we
have
like
the
application
compiled
with
debug
simple
of
the
relevant
version
we
can.
E
We
can
actually
get
a
pretty
good
look
about
like
what
are
the
different
offsets
and
how
we
should
instrument
this
specific
version,
but
because
we
do
it
once
per
application,
we
doesn't
require
the
target
process
to
have
12
symbols
or
any
debug
symbols
because,
like
we
do
it
in
a
in
a
different
Pipeline,
and
we
have
like
this
database
of
mappings
I
hope
it
was
clear.
It's
a
it's.
A
little
complicated
burgundy,
but
I
can
I
can
do
a
few
links
and
references
and
like
everything,
is
up,
insulted,
look
at
it.
B
Well,
I
think
that's
a
question
for
both
projects
actually
as
to
what
that
donation
process
looks
like
that's
the
first
thing
that
kind
of
came
out
to
me
and
like
what
the
transition
would
look
like
and
I
think
that's
kind
of
what
the
purpose
of
this
thing
is
here
to
discuss.
If
yeah.
B
The
donation
process
looks
like
like
if
the
owner
current
owner
is
excited
to
hand
it
over
to
the
open,
Telemetry
ownership,
and
then
who
is
there
to
take
that
off
their
hands?
Is
the
next
question
and
how
that
process,
I
think
is
going
to
look,
is
also
important
and
so
I
think
I
think
that
question
kind
of
applies
to
both
into
something
that
was
kind
of
coming
to
my
mind
as
well
Dinesh.
So
thanks
for
bringing
it
out
Eden
prison,
maybe
we
could
just
expand
that
we
only
have
10
minutes
left.
B
First
of
all,
yeah.
Let
me
just
say,
like
I,
really
appreciate
both
these
demos,
like
I,
think
that
anytime,
you
have
a
talk.
If
you
will
that
inspires,
thought,
it's
valued
and
I
have
incredible
amounts
of
ideas
that
are
coming
from
both
of
these
demos,
but
so
what?
What
kind
of?
What
do
you
see
as
the
the
the
Future
Path
forward
for
both
of
these
I'll
start
with
Eden,
because
you
were
just
talking.
E
Yeah
I
think
that
the
goal
of
this
project
is
to
bring
the
same
amount
of
other
instrumentations
that
exist
from
java,
which
I
think
is
like
the
most
mature
products
from
attention.
Basically
to
go
and
yeah.
That's
the
goal
and
I
think
that,
on
the
same
topic,
I
think
it
can
be
really
great
for
open
Telemetry
as
a
project.
We
could
basically
go
to
any
any
cncf
project
any
go
project
and
like
give
them
instrumentation
immediately
without
having
to
open
pull
requests
on
the
accident
to
instrument
their
applications.
B
And
so
about
the
donation
side,
though,
is
keval
looking
to
just
hand
over
these
repos
or
I
mean
or
piecemeal
like,
but
it
just
essentially
like
the
ownership
of
that
code.
E
That
we
would
be
happy
to
continue
working
on
it.
We
are
continuing
to
walk
on
it,
so
we're,
of
course,
happy
to
to
get
more
people
involved.
This
is
like
the
reason
that
we
made
it,
but
yeah.
We
will
definitely
continue
to
develop
it
and
maintain
it
like
regard
regardless.
If
we
will
choose
to
start
with
the
sauce
base
or
the
APF
based,
we
will
continue
to
welcome.
B
So
one
of
the
things
that
I
I'm
worried
about,
though,
is
that
if
we
move
this,
the
ownership
of
this
code
for
key
Val
into
the
open
Telemetry
space,
there
are
added
restrictions
where
we
need
to
have
consensus
amongst
vendors,
which,
personally
speaking,
I've
never
had
it
being
an
issue.
In
fact,
the
collaboration
kind
of
what
you're
saying
has
been
a
benefit,
but
I
just
want
to
make
sure
that
key
Val
would
be
okay
with
that
I
guess
in
in
the
ownership
transfer.
B
B
Gotcha.
Okay
and
then
is
that
also
a
similar
thing
for
you.
C
B
Okay,
yeah,
that's
a
great
question:
Dinesh
I
didn't
know
if
you
have
any
more
questions
about
the
demo
I'll
hand
it
back
to
you.
D
I
had
a
question
about:
how
are
you
handing
distributed
tracing?
Basically
in
the
slide
you
had
like
create,
span
and
like
how
are
you
propagating
the
context
from
one
application
to
other
application?
I
didn't
get
how
it
was
it's.
It's.
E
According
to
the
w3c
format,
it's
an
additional
header
I
think
it's
called
price
parent
and
like,
if,
like
the
communication
is
happening
over
HTTP,
will
be
additional
HTTP
header,
it's
overgrpc.
It
will
be
an
additional
glpc
header
and
like
this,
plays
very
well
with
the
entire
open,
Telemetry
ecosystem.
So
if
you
will
have
like,
on
the
other
end
like
a
instrument
and
Java
application,
they
expect
this
header
to
be
in
place
with
the
with
the
relevant
Trace
identity.
So
you
will
eventually
get
a
well-formatted
distributed.
Trace.
D
That
makes
sense
thanks.
That's
all
I
had.
B
Awesome
so
I
want
to
be
conscious
of
time.
We
only
have
five
minutes
left
I
do
wanted
to
maybe
just
jump
into
what
our
next
steps
are.
One
of
the
things
that
is
kind
of
standing
out
to
me,
and
maybe.
C
B
Is
kind
of
what
Robert
was
talking
about
with
what
you
would
classify
as
automation
or
not
is
I
wonder
if
both
of
these
projects
living
in
the
same
repository
as
a
misstep
from
the
get-go
and
so
I'm
wondering
if
there
is
a
need
here
for
two
repositories
or
if
we
can
merge
I,
think
Eden,
you
kind
of
pointed
out
that,
like
it'd,
be
the
evpf
solution,
I
think
is
is
more
in
line
with
with
Java
automation.
B
Project
is,
which
is
essentially
like
its
own
ecosystem,
that
is
added
to
as
time
evolves
and
the
more
that
I'm
looking
at
the
the
source
code.
Modification
I
do
wonder
if
that
could
actually
live
in
the
opensometry
contribute
mode
and
so
I'm
going
to
make
that
proposal
is
there?
Is
there
a
possibility
that
we
could
have
this
repository?
What's
it
called.
C
B
For
the
ebpf
and
maybe
even
rename
it
so
it's
more
around
stat
and
then
have
the
source
code
modification
live
in
the
contribute.
Would
that
be
something
that
people
are
open
to
I'd
love
to
hear
our
thoughts
on
that
I?
Guess.
F
I
think
I
think
also
in
future.
We
can
always
you
know,
change
our
mind
and
put
when
when
we
think
that
the
source
is
more
stable,
more
production
and
difficult
always,
you
know,
transfer
this
code
to
instrumentation
right
because
right
now,
in
my
opinion,
this
evpf
looks
more
mature
and
for
sure
it's
used
by
customers
right
at
this
point
of
time,.
A
B
I
I
wouldn't
want
to
say
that
this
repository
is
for
the
mature
code,
in
fact
actually
I'd
probably
say
that
it
isn't
and
that
it's
actually
really
sustainable
right
off
the
bat
but
I
I
do
and
not
neither
would
they
contribute
one
either.
But
I
I
want
to
say
that,
like
the
source
code,
modifications
really
it's
a
place
that
we
already
funnel
a
lot
of
users
and
open
something
to
go
to
go
right.
B
If
you
can't
find
a
library
that
already
exists,
this
is
a
great
tool,
so
you
can
start
are
building
your
code
if
we
build
in
the
debug
symbol
stuff,
like
maybe
it's
a
great
tool
to
also
like
run
it
in
parallel,
but
I
think
that
that
seemed
to
me,
like
a
better
location,
to
start
with
I
also,
it
would
really
I
think
be
a
problem
if
you
had
two
really
separate
Solutions
living
in
the
same
ecosystem
that
evolved
to
be
full
featured
systems
and
the
structure
wasn't
there.
B
B
We
are
Adam
two
minutes
and
30
seconds,
so
I'm
gonna,
say
I
would
like
to
I
I
took
notes
during
this
meeting.
I'd
like
to
I
think
take
that
idea
that
I
just
had
about
the
structure
of
where
we
will
have
these
projects
laid
out
and
make
a
proposal
and
I
will
open
an
issue
for
this.
I'll.
Take
this
as
an
action
item
in
the
agenda
to
to
lay
this
out.
I
think
I.
B
It
was
talked
about
last
time
to
work
on
these,
both
in
parallel
and
I
was
a
little
hesitant
because
of
the
added
developer
overhead,
but
I'm,
also
looking
at
the
full
featured
nature
of
what
these
proposals
include
like
they're,
they're,
working
prototypes
at
least
or
or
stuff.
That's
used
by
code
so
are
used
by
customers.
So,
like
I
I
wonder
if
it's
just
one
of
those
things
where
you
could
immediately
just
start
picking
this
up
and
if
it's
not
released
as
a
stable
release,
then
we're
not
as
beholden
to
the
actual
decisions.
B
So
I'm
going
to
try
to
put
these
down
in
words
in
an
asynchronous
issue
and
have
people
notified
by
this
I.
Don't
know
if
I'm
gonna
get
to
it
today,
but
I
can
I
can
say
that
I
will
get
to
it
by
tomorrow
and
I
will
post
it
in
the
slack
Channel.
If
everyone
thinks
that
that's
a
good
action
I
don't
want
a
good
place
to
take
our
next
lead
on,
and
then
we
can
build
off.
B
Yeah
I
would
love
to
have
talked
about
it
more
in
this
meeting,
but
we're
running
close
on
time,
so
I
just
wanted
to
yeah
just
make
sure
we
have
something
for
the
next
time:
okay,
well
cool.
Well,
then
we
can
edit
here
per
second
thanks
a
bunch
again
for
these
demos.
B
I
do
want
to
say
both
of
your
projects
are
extremely
inspiring
and
and
I'm
also
really
excited
about
evpf
and
open
Telemetry.
So
yeah
I
definitely
think
that
you
did
great
work
and
I
want
to
try
to
progress
these.
So
thanks
a
bunch.