►
From YouTube: 2022-02-01 CNCF TAG Observability Meeting
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
B
D
D
Hi,
so
we
have
a
few
speakers
today
with
some
time
constraints
that
we're
trying
to
get
into
the
first
half
an
hour.
So
I
want
to
just
open
properly
here
and
say:
welcome
all
this
is
a
cncf
sponsored
video,
so
the
code
of
contact
does
apply.
Please
don't
put
anything
in
the
chat
that
would
be
in
violation
of
that
and
with
that
we
have
a
fairly
full
agenda
today.
D
If
anyone
doesn't
have
a
link
to
the
doc,
I
will
place
that
in
the
chat
now
feel
free
to
or
please
do,
sign
in
and
indicate
your
attendance
I'm
going
to
skip
over
administrative
and
things
like
that.
There
was
a
tsc
meeting
today
and
I
gave
an
update
on
the
tag.
It
was
the
last
for
some
of
the
toc
members
liz
price
and
a
few
others.
This
was
their
last
tlc
meeting
and
elections
are
very
very
soon
here.
D
E
Okay,
well
thanks
matt
for
inviting
me
so
yeah
today,
I
wanted
to
tell
you
a
little
bit
about
the
cloudnet
native
glossary
because
apparently
is
it?
Is
it
too
big?
I
see
some
no
and
it's
a
new
cncf
project
and
cosmetics
said
that
there
is
some
interest
in
contributing
in
general
to
different
projects.
So
I
just
wanted
to
tell
you
a
little
bit
about
it.
I
did
do
a
little
presentation,
very
short,
so
for
those
who
wanted
to
talk
after
no
worries.
E
And
oh,
no
one
over
so
basically
we're
trying
to
create
a
glossary
that
explains
all
cloud
native
firms
to
engineers
just
getting
started,
but
also
to
people
with
no
technical
background
right.
So
we're
really
focusing
on
explaining
things
in
very
simple
words
that
are
accessible
to
anyone.
No
tech
charting
is
is
allowed.
Sometimes
they
sneak
a
little
bit
in
and
that's
where
we
need
help,
maybe
to
improve
those
terms
as
well
and
as
it
turns
out,
that's
actually
really
really
hard
right.
E
Explaining
things
in
like
explaining
complex
things
and
simple
words
is
really
challenging,
but
it's
also
a
way
to
really
verify
or
kind
of
make
sure
that
you
really
understand
it
right,
because
if
you
do
manage
to
do
that,
you
really
have
got
it
and
it
officially
launched
at
coupon
n
a.
E
And
so
basically,
right
now,
so
we
officially
launched
a
coupon
in
a
and
are
now
right
really
trying
to
focus
saying
on
getting
more
contributors
and
we're
also
trying
to
translate
it
into
different
languages,
and
so
just
wanted
to
maybe
show
it
a
little
bit
if
you
haven't
seen
it
oops.
E
E
If
you're
interested
in
contributing,
we
created
a
contributor
how
to
contribute,
guide
the
different
ways
you
can
contribute.
We
have
slack
channels
and
so
on,
and
here
like
we
even
made
it
for
people
who
are
not
at
all
technical.
E
It's
explained
in
in
in
details
as
well,
so
to
make
it
accessible,
because
you
don't
necessarily
have
to
be
familiar
with
github
to
contribute,
if
you
understand
it
technically
and
then
we're
also
translating
it
currently
and
you
can
find
the
stack
style
guide
here
and
all
pages
have
all
the
terms
have
the
ability
to
be
edited
here.
It
will
lead
you
right
into
the
github
repository.
E
There
are
tons
of
issues
here.
People
are
super
active
right
now,
which
is
very
very
exciting
again.
We
just
we
literally
just
launched
it
in
a
and
we're
seeing
lots
of
people
helping
each
other
on
slack,
which
I
did
not
expect
at
all
and
and
yeah
I
mean
like
it's
very
active
and
also
on
the
translation
part.
E
So
if
you're
interested
this
is
last
night,
if
you're
interested
you
can,
you
can
submit
new
terms
like
if
you
just
have
ideas
of
things
that
you
see
that
are
missing.
That's,
like
the
easiest
thing
just
submit
an
issue.
You
can
also
create
a
new
term
like
create
a
pr
you
can
improve
existing
ones.
As
as
I
mentioned,
we
were
a
very
small
team
with
the
first
50
terms.
We
had
a
few
contributions,
but
we
really
were.
I
think
we
had
like
a
goal
of
creating
three
two
two
terms
per
week,
so
we
really.
E
It
was
a
lot
of
work
to
get
to
coupon
and
a,
and
sometimes
we
may
not
have
been
complied
with
our
own
rule
of
simplicity,
and
then
you
can
also
help
translate
the
glossary
into
your
native
language.
We
have
currently
existing
teams
from
korean
portuguese,
italian,
spanish,
arabic,
bengali
and
hindi,
and
these
are
the
active
ones.
E
We
have
some
other
ones
that
have
started
that
who
started
creating
it,
but
they
haven't
been
that
active,
but
you
can
also
create
your
own
team
if,
if
the
language,
if
there's
no
team
for
your
language
as
well
yeah,
so
that's
basically
it
if,
if
anyone
is
interested,
the
first
step
would
really
be
to
to
to
join,
to
join
the
glossary,
the
glossary
channel.
We
also
have
the
glossary
localizations
channel
on
the
cncf
chat
slack.
If
you're
interested
in
translating
it
again,
it
is
very
active.
E
People
are
engaging
a
lot.
So
it's
a
great
place
to
ask
questions,
get
help
or
whatever.
E
However,
you
want
to
engage
with
the
community
and
yeah,
just
that
would
be
how
to
get
started.
D
Thank
you
so
much.
I
was
wondering
if
you
could
also
cover.
If
you
have
time
what
is
the
business
value
subcommittee
and
how
does
that
fit
into
the
cncf
and
tags
and
the
ontology
of
all
of
that.
E
Yeah,
so
it
all
started
with
the
business
value
subcommittee,
where
I
am
court
here
with
jason
morgan
and
the
idea
was
to
create
content
or
resources
for
people
who
are
not
technical.
Well,
one
of
the
things
that
we've
realized,
of
course,
as
you
all
know,
is
that
cloud
native
is
becoming
more
mainstream.
E
More
and
more
people
are
touched
by
it
that
are
not
necessarily
technical
right
like
these
are
like
huge
projects
like,
for
instance,
migrating
your
application
to
microservices
a
huge
huge
project
costs,
millions
of
dollars,
millions
of
dollars
potentially,
and
so
the
c-suite
is
involved
in
that.
So
a
lot
of
people
need
to
understand
it,
but
like
if
you
look
at
the
content
on
there,
it's
always
very
much
targeted
towards
people
with
technical
background.
So
it's
really
difficult
to
understand
what
and
what
this
is
all
about.
E
So
we
started
the
business
value
subcommittee
with
the
goal
of
creating
content
for
that
target
audience
like
making
it
more
accessible
to
anyone,
no
matter
what
background
they
have
and
before
starting
anything
else.
We
thought
like.
Okay,
if
we
start
creating
content,
we
need
to
first
agree
on
the
different
terms,
because
otherwise
it's
going
to
be
very
difficult
and
also
we're
always
going
to
we're
going
to
refer
back
to
kubernetes
containers
apis
over
and
over
again.
E
So
we
decided
the
first
project
should
be
a
glossary
where
we
explain
all
these
terms
and
then
we
can
create
more
content
and
then
link
to
that
specific
definition
easily
and
don't
have
to
explain
it
over
and
over
again.
E
So
it
was
supposed
to
be
this
little
kind
of
thing
that
we
wanted
to
do
to
start
something
else,
but
it
turned
to
be
a
lot
more,
a
lot
bigger
than
we
thought
it
would
be
and
like
yeah
now,
it's
really
flourishing
with
yeah
a
lot
of
contributors
so
far,
but
that's
how
it
fits
in.
So
we're
also.
E
The
goal
is
also
to
create
more
things
for
the
business
value
subcommittee,
so
there
this
is
one
project
and
we're
working
on
another
one
which
is
explaining
we're
trying
to
create
a
comparison
table
for
cnc
we're
going
to
start
with
cncf
projects
and
then
opening
it
up
for
different,
open
source
projects
where
projects
can
there's
a
framework
where
projects
can
explain
or
say
what
they
are.
E
What
are
the
most
important
features,
a
short
description
and
so
on,
because
one
of
the
issues
that
we
realized
is
that
it's
really
hard
to
it's
really
hard
for
users
to
understand
to
have
an
overview
of
what
projects
exist.
There's
a
lot
of
content,
but
it's
always
a
deep
dive
but
kind
of
understanding
or
getting
a
sense
of
of
what
what
these
each
project
is
in
a
high
level
and
then
deciding
where
you
want
to
dig
deeper.
E
That
kind
of
content
is
missing
and
another
thing
that
we
created
is
also
the
cncf
landscape
guide.
So
if
you
go
into
the
landscape
right
now,
there's
a
little
guide
that
explains
the
landscape.
So
that's
part
of
the
business
value
subcommittee
as
well.
So
if
you
have
any
ideas,
come
join
us.
Thank
you.
D
Are
there
any
questions
before
we
move
on.
D
Okay
with
that,
I
think
next.
Thank
you,
catherine
very
much.
I've
captured
some
notes
and
if
I
could
get
this
the
link
to
your
slides
offline
or
if
you
want
to
paste
them
into
the
meeting
notes,
that'd
be
awesome
for
the
folks
that
couldn't
be
here
today.
Next
up
is
an
update
from
pixie
and
to
provide
some
context.
Bumblebee
is
a
project
that
was
that
we're
gonna
talk
about
that.
D
The
folks
will
talk
about
after
pixie
that
is
centered
around
ebpf
and
providing
developer
tooling,
and
I
don't
want
to.
I
don't
want
to
mistake
the
project
goals,
but
pixie
last
came
to
the
tank
last
year
in
may,
I
believe
and
kind
of
did
a
bit
of
a
show
and
tell,
and
so
as
a
cncf
project,
that's
engaged
with
ebpf
as
part
of
the
part
of
the
project.
In
addition
to
just
get
an.
F
Update
yeah,
we
thought
it
kind
of
fit.
F
I'm
new
thanks
matt,
so
I'm
zane
and
I'm
one
of
the
project
maintainers
of
pixie,
for
for
just
some
longer-term
contacts,
pixie
was
built
by
pixie
labs,
where
I
was
the
co-founder
and
ceo.
We
actually
got
acquired
by
a
new
relic
in
2020,
and
we
open
sourced
pixie
and
contributed
it
to
the
cncf
and
we're
now
a
sandbox
project
and
hoping
to
you
know,
become
like
an
incubating
project
and
and
move
on
in
the
cncf
project
lifecycle.
F
So
I
didn't,
I
don't
have
any
like
formal,
slides
or
anything
prepared
today.
So
I'll
just
talk
through
it,
I'm
actually
hoping
that
you
know
moving
forward
if
we
can
have
an
update
on
pixie
every
so
often
in
this
meeting
we
can
actually
have
some
slides
put
together,
give
overviews
of
what
we're
working
on
what
we
plan
to
do,
but
for
folks
that
are
not
like
really
familiar
with
that.
F
Pixi
is
a
kubernetes
observability
system
which
basically
uses
evpf
to
capture
data
and
uses
all
the
kubernetes
metadata
to
actually
help
like
make
it
adjustable.
So
we
can
take
all
the
ebp
update
and
present
it
to
you,
as
in
you
know,
here's
the
traffic
from
this
service
and
here's
the
actual
http
request
bodies,
and
on
top
of
that
we
have
this
layer.
That's
you
know,
based
on
top
of
pandas,
to
be
able
to
work
with
and
analyze
the
data.
F
So
partly
what
we're
trying
to
do
with
pixi
is
make
it
very
easy
to
capture
data,
but
also
very
easy
to
build
workflows
at
that
will
then
allow
you
to
you
know,
do
something
in
your
system.
So,
for
example,
at
the
last
coup
con
we
had,
we
had
a
demo
on
how
to
actually
gather
metrics
from
pixie
like
actually
message
information
and
then
use
that
to
do
hot,
auto
scaling,
and
we
can
take
a
look
at
like
pretty
detailed
information
around.
F
You
know
on
actual
content
of
the
messages,
to
determine
that.
Another
thing
is,
you
know,
doing
things
like
sql
injection
and
attack
detection.
So
we
really,
we
really
plan
to
be
like
kind
of
like
a
horizontal
layer
that
can
capture
the
data
and
present
it
for
like
different
use
cases,
and
we
have
this
concept
of
scripts
that
you
can
actually
run
in
real
time
on
your
system
to
be
able
to
process
this
information.
F
So
that's
where
we're
at,
like,
I
said
you
know,
we're
still
a
very,
very
new
project
and
we're
just
starting
to
get
to
the
point
where
we're
accepting
external
contributions
and
moving
into
larger
systems.
You
know
to
be
completely
upfront.
We
haven't
even
moved
all
of
our
issue
tracking
into
github,
yet,
which
is
something
that
we're
planning
to
do
and
release
our
public
roadmap.
D
I
I
was
wondering,
if
you
might
you
if
you
were
michelle,
could
speak
to
what
it's
been
like
to
build
an
ebpf.
You
know
based
solution
with
the
tooling
that
has
existed
for
quite
a
long
time
and
then
some
of
it
more
recent
like
could
you
maybe
paint
a
picture
of
you
know?
Was
that
an
easy
thing,
a
hard
thing?
You
know
what
what
was
the
experience
around,
that
the
state-of-the-art
with
tools
and.
F
And-
and
things
like
that,
yeah
absolutely
so
one
of
the
things
that
we've
always
done
with
pixi
is,
you
know
we
always
bloody,
simple
prototypes
of
pppf,
and
I
think
our
biggest
challenge
has
always
been
taking
something
simple
that
works
in
ebpf
and
making
it
robust
and
reliable
across
many
many
different
machines
and
configurations
and
operating
systems.
You
know
we
still
require.
I
think,
like
4.12,
is
our
minimum
kernel
version
that
we
require
michelle
correct
if
I'm
wrong,
but
I
think
that
is
that
is
our
minimum
requirement
right
now.
F
Maybe
it's
4
14.,
but
you
know
we
try
not
to
track
to
the
latest
kernel
version,
because
you
go
to
a
lot
of
deployments.
People
don't
have
that,
like
a
lot
of
people,
don't
run
the
latest
greatest
systems,
so
part
of
our
challenge
has
always
been
like
trying
to
get
this
deployed
and
running
reliably
without
losing
data
or
without
having
like
some.
You
know
insane
resource
consumption.
Actually,
that's
part
of
the
biggest
battle
we're
fighting
with
pixie
right
now
that
we're
hoping
to
resolve
is
just
our
resource.
F
So
in
terms
of
challenges-
let's
say
you
know
the
tooling
for
evpf
is
not
particularly
friendly.
You
can
get
things
running
it's
hard
to
productionize
them
and
after
you
productionize
them.
You
then
run
into
other
issues
like
okay.
Well,
maybe
the
resource
consumption
is
too
high.
How
do
we
actually
deal
with
the
buffer
sizes
if
the
buffer
sizes
are
too
small?
You
start
losing
data.
The
buffer
sizes
are
too
big.
You
can
see
too
much
memory.
You
know,
people
familiar
with
ebp
up
here
were
probably
like.
F
Oh
yeah,
I
understand
how
this
works
and
what
the
challenges
are
over
there.
So
a
lot
of
our
stuff
has
just
been
around
like
tweaking
things
and
making
things
work
out.
We
added
a
new
capability
to
pixel
last
year
that
allows
you
to
do
continuous
profiling
of
applications
using
evpf,
and
you
know
it
was
relatively
easy
to
get
something
working,
but
getting
that
working
reliably
at
scale.
F
You
know
with
binaries
that
you
know
sometimes
like
people
building
static,
binaries
or
binaries
can
be
like
three
four
hundred
megabytes
that
can
actually
introduce
a
significant
amount
of
memory.
Overhead
we're
trying
to
like
resolve,
addresses
and
stuff
inside
of
that
binary.
F
B
F
So,
as
of
today,
pixi
needs
to
run
on
a
kubernetes
machine.
We
plan
to
remove
that
limitation.
So
the
way
we
think
about
pixie
is
that
there
is
a
data
system
and
then
there's
a
data
collection
stuff.
The
data
system
will
most
likely
require
kubernetes
for
the
foreseeable
future,
but
we
will
allow
like
our
pens,
which
are
called
the
pixie
edge
modules,
to
be
able
to
run
either
on
a
linux
node
or
on
a
kubernetes
node.
F
F
F
D
Cool,
I
just
realized
I'm
signed
in
as
tag
observability,
because
I
was
uploading
videos,
so
my
name
is
matt,
not
tag
observability.
Are
there
any
questions
for
for
the
pixie
folks
or
or
any
additional
updates?
I
know
we're
trying.
We
had
some
time
pressure,
but
before
we
move
on
to
bumblebee.
D
Okay,
thank
you.
Thank
you
very
much
zane
and
michelle.
C
A
All
right
thanks
flynn,
hey
everyone,
my
name
is
lawrence
and,
like
lynn
said,
I'm
one
of
the
core
maintainers
of
bumblebee
right
now.
Bumblebee
is
a
very
early
project,
so
I
would
say
it's
not
quite
to
where
you
know.
Maintaining
maintenance
is
a
lot
of
work,
but
we
are
very
excited
about
the
project,
and
so
I
want
to
talk
a
little
bit
about
it.
A
Let
me
go
ahead
and
share
my
screen,
so
I
have
some
slides
that
I
kind
of
repurposed
that
hopefully
you
should
be
able
to
see
my
screen
I'll
run
through
these
fairly
quickly,
but
just
to
kind
of
give
a
sense
of
what
bumblebee
is
so
bumblebee.
Let
me
get
into
slideshow
this.
This
description
comes
directly
from
the
readme,
but
it
does
a
pretty
good
job
of
capturing
it.
So
bumblebee
intends
to
help
run,
build
run,
distribute
ebpf
programs
using
oci
images.
A
It
allows
you
to
focus
on
writing
ebpf
code
while
taking
care
of
the
user
space
components
automatically,
exposing
your
data
as
metrics
or
logs.
So,
like
we
just
heard,
you
know
a
very
accurate,
accurate
statement
from
the
pixie
folks.
You
know
writing.
Dpf
code
is
hard,
and
so
one
of
the
goals
of
bumblebee
and
matt,
I
think
you
did
a
good
job
of
explaining
at
the
beginning.
You
know
one
of
the
one
of
the
core
aspects
of
bumblebee
is
the
developer,
tooling
component,
and
so
the
observability
is
kind
of
something
that
you
know.
A
We
want
to
help
solve
observability,
but
we
also
want
to
help
solve
the
challenge
of
running
or
writing
bpf
code
and,
as
far
as
writing,
ppf
code
goes.
A
You
know
a
lot
of
the
existing
tools
like
pcc
and
so
on
that
that
that
requires
you
to
be
able
to
compile
your
your
bpf
code
on
the
fly
on
the
system
that
you
want
to
run
your
probes
or
you
know
whatever
it
is,
that
you're
running
you
need
to
be
able
to
compile
that
on
the
fly
and
so
libby
pf,
which
is
you
know
the
in
entry
internal
kind
of.
A
Basically,
it's
it's
a
library,
that's
trying
to
abstract
away
some
of
that
and
allow
you
to
you
know,
write
bpf
code
programs
that
can
run
on
any
version
of
the
kernel
that
supports
btf,
which
is
bpf
type
format,
and
so
with
bumblebee.
A
We
kind
of
saw
that
as
an
opportunity
to
help
simplify
the
user
developer
experience
even
more
so
and
so
bumblebee
depends
on
lib
bpf
and
what
we
try
to
do
is
allow
you
to
write
lib,
bpf
compatible
code
and
only
that
so,
in
other
words,
right
now
at
least
the
common
use
case
when
you're
actually
writing
code.
You
know
there
are
other
tools
like
bpf,
trace
and
pixi's.
A
A
good
example
is
where,
as
well,
where
you
kind
of
abstract
away
the
actual
bpf
code,
which
in
a
lot
of
cases
is,
is
great,
but
there
are
some
times
where
you
want
to
actually
write
bpf
code
and
especially
just
for
learning
right.
You
want
to
be
able
to
write
programs
that
interact
with
the
kernel
and
you
kind
of
get
that
feedback
of
you
know,
writing
some
code
and
executing
it.
A
Seeing
the
you
know,
tracing
data
or
whatever
it
is
that
you're
looking
for,
and
so
with
with
with
bumblebee,
we
tried
to
abstract
away
the
user
space
component.
So
with
the
lib
bpf
program,
you
you
write
your
probes
or
your
your
trace
points
or
whatever
the
pro
the
bpf
program.
Is
you
need
to
write
that
you
need
to
also
write
the
user
space
code
which
will
load
the
program
into
the
kernel,
create
the
bpf
maps,
which
is
how
your
program
talks
to
you,
know
user
space,
and
you
can
actually
get
the
data
out.
A
You
need
to
load
that
into
the
kernel.
You
need
to
attach
it
to
the
do
whatever
function.
You
know
if
it's
a
k,
probe
or
a
trace
point
or
whatever
it
is,
and
then
you
need
to.
Actually
you
know
extract
that
data
format
it
and
outputted,
and
so
in
a
lot
of
cases.
A
You
know
unless
you're
writing
a
very
sophisticated
program,
a
lot
of
cases
that
user
space
component
is
essentially
boilerplate,
and
so
one
of
the
things
that
bumblebee
also
tries
to
solve
is
to
abstract
that
away
to
where
all
you
really
need
to
do
is
write
your
bpf
code,
that's
interacting
with
the
kernel
and
then
the
the
user
space
kind
of
runner
of
bumblebee
will
be
able
to
dynamically
determine
those
types
of
the
data
that
you're
storing
and
then
automatically
display
it.
You
know
right
now
we
have
kind
of
a
tui,
a
text.
A
You
know
interface.
That
shows
you
know
what
is
in
your
in
your
maps,
but
we
also
output
metrics
as
prometheus
in
prometheus
format.
Right
now,
automatically
based
on
those
types,
and
so
it's
a
lot
easier
to
see
we'll
get
into
a
demo
of
time
permits,
and
I
have
some
slides
that
kind
of
show
it
a
little
bit
more.
A
A
You
know,
iterate
on
your
programs,
so,
for
example,
with
bumblebee.
We
have
a
few
examples.
We
need
a
lot
more,
but
we
have
a
few
examples
that
are
stored
in
our
github
container
registry.
So
what
we
can
look
at
here
is
with.
A
So
this
is
trying
to
kind
of
mimic
that
environment
to
allow
you
to
easily
you
know
kind
of
fit
into
your
existing
workflows.
Okay,
so
that's
kind
of
the
overview.
These
are
some
diagrams
that
hopefully
help
the
build
process
again
we.
So
I
don't
think
I
did
a
good
job
explaining
this
the
the
build
is
we
have
a
container
a
build
container
that
really
all
it
does
is
package
kind
of
the
the
tooling.
You
need
to
build
lid,
bpf
programs,
so
things
like
llvm
and
clang
the
headers.
A
So
if
you're
using
libby
pf
you
you
commonly
will
use
something
called
vm
linux,
which
is
kind
of
the
the
abstracted
types
from
the
kernel
and
that's
what
allows
you
to
run
on
any
kernel
that
supports
btf,
but
all
of
that
is
kind
of
packaged
in
a
container
to
make
it
easy
to
get
started.
You
know
there's
nothing
too
special
going
on
in
there,
but
it
does
reduce
the
barrier
of
entry,
at
least
that
at
least
we
believe.
A
So
so,
if
you
were
to
do
like
a
b
build
and
you
have
your
bpf
code
and
again
only
your
bpf
code,
you
do
a
b
build
bpf.c
or
whatever
your
file
is,
and
then
you
give
this
in
this
example.
It's
my
underscore
bpf
v1
tag
and
that's
the
oci
image
that
will
contain
your
actual
probe
or
you
know.
A
Whatever
your
program
does,
so
we
use
that
container
that
build
container
to
compile
it
to
the
bpf
representation
and
then
package
that
in
the
oci
image
that
you
can
then
use
to
push
you
know
to
whatever
registry
you
want,
then
so
yeah.
This
is
the
push
right.
So
in
this
example,
this
is
the
github
container
registry,
so
you
can
do
a
b
push
and
then
that
will
push
the
actual
oci
image
with
your
program
to
the
registry
and
then
running
it
you
can
just
do
a
b
run.
A
You
know,
give
that
same
image
name
and
it
will
pull
your
image.
And
now
you
have
that
essentially
in,
like
your
local
store,
you
know
similar
to
like
when
you're
pulling
docker
images
right
and
then
then
it
goes
through
kind
of
the
standard,
loading
and
kind
of
bootstrapping
of
a
bpf
program.
Where
you
create
the
maps,
you
need
load
the
program
into
the
kernel,
attach
it
to
the
right,
the
hook
point,
and
then
it
will
read
the
so.
A
Your
bpm
program
is
going
to
update
your
maps
and
then
based
on
some
conventions
that
we
have.
You
know
really
it's
just
the
section
name
which
we'll
see
here
in
a
second
it
will
dynamically
read
those
maps
and
output
the
data
either
as
a
you
know,
in
a
pretty
text,
interface
in
your
in
your
terminal
or
as
metrics
or
both,
and
we
also
we,
the
the
user
interface
is
kind
of
just
like
a
you
know,
a
nice.
A
It's
it's
a
cool,
getting
started
tool.
You
can
also
shut
that
off
and
you
know
we
have
plans
to
maybe
be
able
to
make
it
like
a
standard
output.
So
you
know
if
you
want
it
running
the
container
or
whatever
else,
but
right
now,
really.
The
core
functionality
is
that,
based
on
the
types
of
data
that
you're
putting
into
your
maps,
we
can
dynamically
determine
that
using
btf.
Just
like
the
kernel,
you
know
just
like
the
lib
epf
uses,
btf
types
to
allow
you
to
to
run
on
any
version
of
the
kernel
supports
btf.
A
We
use
that
btf
type
of
your
your
data
that
you're
putting
into
your
map
to
be
able
to
dynamically
understand
the
the
essentially
the
data
structure
and
that's
how
we
can
kind
of
dynamically
print
out
in
the
correct
format
what
you
are
watching
in
your
program
and
so
this
kind
of
goes
into
it.
It
might
be
a
little.
I
don't
know
how
far
you
know
into
it.
We
want
to
get,
but
really
the
core
part
here
is
what
I
was
just
talking
about
as
far
as
the
types
go
so
on
the
left.
A
This
is
an
example
of
basically,
if
we're
writing
some
bpf
code
to
do
track,
tcp
connections,
we
can
use
a
hash
map
to
create
a
vpf
map
of
a
hash
map
type
and
in
that
we
want
to
store,
for
example,
the
source
address
and
the
destination
address
which
would
be
up
here
and
those
are
stored,
as
this
ipv4
address,
which
is,
it's
really
just
a
type
definition
of
the
standard
representation
of
an
ip
address.
A
But
what
this
gives
us
is
that
this
type,
if
you
look
at
the
map
definition,
we
call
out
the
type
here
and
the
the
struct
is
passed
in
as
the
that's
the
key
of
your
hash
map,
and
so
because
we
know
what
struck
what
the
format
of
that
struct
is
later
on.
When
we
actually
run
and
read
that
data,
we
can.
We
know
that
the
type
is
an
ipv4
address,
so
we
can
format
it
appropriately
and
then
your
bpf
code
doesn't
really
change.
A
This
is
pretty
consistent
across,
especially
with
bpf
style
code,
but
really,
you
know
you're
just
reading
you're
getting
some
you're
getting
a
socket
address,
essentially
from
an
event
and
putting
it
into
the
map
and
then
that's
it
b
will
be
able
to
bumblebee
will
be
able
to
read
that
data
so
to
actually
kind
of
see
it
in
action
again
taking
that
data
type.
A
So
when
you
do
a
b
run-
and
in
this
case
this
is
a
hashmap
tcp
connect
program
that
I
kind
of
just
you
know
built
and
I'm
running
it,
and
so
you
can
see
this
destination
address
as
deader
source
address
as
s
adder.
These
types
come
directly
from
our
struct
of
the
key
type
of
that
hash
map,
and
so
we
kind
of
infer
this
again
because
of
the
type
information
in
the
bpf
program
and
that's
the
same
type
information
that
libby
pf
uses
to
kind
of.
A
Allow
you
to
do
the
compile
one
once
run
everywhere.
So
we
know
that
a
d
adder
and
an
s
adder
are
your
ipv4
and
we
can
render
that
out
in
our
ui
accordingly
and
then
one
of
the
other
things
that
we
can
do
is
so
this
section.
Typically,
this
would
be
like
dot
maps,
and
that
would
say
that
you
know
this
is
a
map.
This
is
a
bpf
map
and
that's
how
loaders
that's
how
bpf
loaders
know
that?
Okay,
I
need
to
create
this
as
a
map
in
the
kernel.
A
This
is
what
I'm
going
to
use
to
store
my
data
in
my
program,
there's
a
convention
that
we
added
where
you
know,
for
example.
In
this
case
we
have
a
dot
counter
suffix,
and
that
is
specific
to
be
specific
to
bumblebee,
and
that
tells
us
that
we
want
to
watch
this
map,
but
we
also
want
to
export
metrics
as
a
counter,
and
so
in
our
ui.
A
A
You
know
the
machine
that
I'm
on
to
this
169
254
ip
address
when
I
took
the
screenshot
right
that
had
been
that
a
connection
had
been
established
to
this
tuple
14
times
right,
and
so
we
kind
of
dynamically
do
that
and
keep
track
of
that,
and
so
you
get
the
output
here
on
your
ui.
But
then
the
other
cool
thing
that
we
can
do
is
export
this
as
metrics
and
since
the
the
user
space
kind
of
be
cli
is
written
in
golang.
A
We
get
a
lot
of
stuff
easier
than
if
we
were
to
write
this
in
c,
for
example
right.
So
we
can
in
this
case,
hook
into
prometheus
libraries
and
export
that
same
data
that
we
were
just
looking
at
as
prometheus
metrics.
So
this
is
a
table
graph
of
that
and
then
here's
the
actual
graph.
You
know,
then
this
is
just
using
prometheus
right.
C
So
I
noticed
in
the
meeting
minutes
there
is
somebody
made
a
comment
about
apache
apache2o,
not
cncf.
So
that's
actually
a
pretty
interesting
comment.
It
is
apache
license
as
you
discover
as
far
as
the
project,
not
in
cncf
today,
but
it's
something
we
are
actively
looking
at
yeah.
I
I
put
that
there
just
for
for
context
so
part
of
the
charter
and
the
the
the
role
of
the
the
technical
advisory
group
here
is
to
give.
D
Feedback
to
the
you
know
to
do
the
things
we
do,
but
part
of
that
is
giving
feedback
to
the
technical
oversight
committee
to
identify
gaps
in
the
ecosystem
or
things
that
are
open
source,
but
not
in
the
cncf
versus
projects
that
are
already
in
the
in
the
in
the
cncf
umbrella.
D
If
you
will
so
yeah
that
that
that's
that
that's
the
context,
so
you
know,
but
when,
when
I
when
I
saw
the
bumblebee
had,
oh,
you
know
what
that's
all:
how
to
open
source
the
project.
You
know
that's
sort
of
that's
in
the
in
the
in
the
domain
that
we
focus
on,
so
so
that
that's
the
context
there.
But
that's
that's
great
to
know
that
you're
thinking
about
it
in
those
terms.
C
Yeah
certainly,
and
we
would
appreciate
your
feedback
matt,
you
know
if
there
are
certain
check
boxes,
we
have
a
meet
in
preparation,
for
you
know
position
this
as
a
cncf
sandbox
project.
We
would
love
to
hear.
D
Sure
I
I
think,
that's
probably
outside
the
scope
of
this
meeting,
yeah
and-
and
I
may
be
very
the
right
person,
but
yeah
we
can.
We
can
talk
offline,
there's
a
well-formed
process
that
that
sometimes
involves
this
group,
but
oftentimes
doesn't
yeah.
I
think
I
think
the
folks
that
are
on
the
caller
or
and
or
some
of
the
folks
that
might
see
this
video
later
are
really
the
right
set
of
people
that
that,
if
you're
looking
for
feedback,
you
know
I'm
a
facilitator.
B
B
I
have
a
small
question
because
I've
used
a
cloud
player
project
called
the
bppmdbpf
exporter.
Sorry,
where
you
could
build
your
ppf
program
in
c
and
then
there
is
a
structure
that
will
convert
the
data
of
your
epf
maps
into
prometheus
exporters
directly.
B
My
feedback
from
the
cloud
perspective
was
great,
an
awesome
product,
but
it
was
very
hard
to
configure
it
and
a
very
inconsistent,
like
mentioned
before,
on
the
various
systems,
where
you
run
that
project.
I
would
be
very
interested
if
you
can
share
any
links
because
I
would
like
I
definitely
want
to
have
a
try
on
this
one
to
compare
it.
B
So
that
would
be
for
me,
like
a
a
b
test,
to
compare
my
experience
between
the
clover
exporter
and
the
and
your
technology,
because
it's
very
interesting,
but
now
for
now
I
I
I'm
very
hard
because
I
need
to
play.
I
I
very
hard
to
understand
what
you
provide
extra
compared
to
what
cloudflare
provided
a
couple
of
years
back.
D
Perhaps
that
might
make
sense,
and
that
might
be
a
perfect
segue
to
your
offer
lawrence
or
I'm
doing
a
demo.
A
If,
if
that's
something
you'd
like
to
do,
if,
if
it's
not
nothing,
you
tell
me
yeah,
no,
that
that
makes
sense.
I
do
what
was
the
problem.
The
oh
cloud
fares,
ebpf
exporter,
okay,
I
see
them
in
the
chat
now.
Okay,
yeah,
that
look.
We
can
definitely
do
a
demo.
I
think,
as
far
as
the
prometheus
part
goes,
there's
probably
not
a
whole
lot
of
difference.
A
I
actually
am
not
too
familiar
with
that
one,
I'm
going
to
open
that
tab,
so
I
can
look
at
it
after
this,
but
the
so
you
know
if
they're,
I'm
assuming
they're
they're,
taking
some
data
from
an
ebpf
program
and
exporting
it
as
prometheus
metrics.
So
in
that
case
you
know,
there's
not
a
whole
lot
of
difference
there.
I.
C
Think
they
are
based
on
the
bcc
which
yeah
we
are
based
on
a
modern
navy,
bpf.
A
Yeah
good
point
yeah,
so
this
yeah
I'll
definitely
need
to
kind
of
do
my
own,
a
b
testing
as
well
on
that
to
understand
this
one
a
little
bit
more,
but
I
think
the
other
kind
of
components
as
far
as
the
really
the
the
oci
kind
of
packaging
of
the
bpf
probe
or
trace
point
or
whatever
it
is,
is,
is
one
difference
and
then
also
the
just
the
the
abstracted
hopefully
simplified,
build
process
for
lid
bpf,
compatible
programs,
but
yeah,
maybe
a
demo,
will
help
you
know
I
I
I
definitely
want
to
dig
more
into
this
evp
exporter,
though,
but
really
kind
of
the
the.
A
I
guess
the
one
of
the
most
helpful
parts
of
it
is
really
the
the
oci
kind
of
at
the
oci
compatible
workflow,
and
so
you
know
I
have
b
downloaded.
I
use
this.
Let
me
make
this
a
little
bit
bigger.
A
I
use
this
install
script
here,
as
most
things
nowadays
have,
but
basically
so
I
have
a
b.
I
have
my
b
binary.
So
if
I
were,
let
me
make
this
a
little
bit
bigger
too.
So
I
have
the
binary
here
on
my
system.
This
is
just
a
this
is
actually
a
debian
box,
but
you
know
any
any
again
any
linux
machine
that
supports
vtf,
which
I
think
was
5.5
or
5.4
and
newer.
A
But
so
I
what
I,
what
the
first
thing
kind
of
I'll
do
as
far
as
like
a
demo
goes.
This
example
here,
that's
on
the
readme
is
pretty
cool,
so
this
is
a
kind
of
a
more.
I
guess,
sophisticated
version
of
the
the
of
the
bpf
program
that
I
was
showing
in
the
slides,
and
so
in
this
case,
I'm
using
sudo
to
run
it
just
because
you
know
to
load.
Bpf
programs
is
a
privilege
action.
We
have
some
docs
where
you
know
you
can
use
capabilities
to
do
this.
A
You
don't
have
to
do
everything
as
sudo,
either
way
for
this
example,
I'm
just
going
to
do
sudo,
but
all
I'm
going
to
do
here
is
a
b
b
run
and
then
this
tcp
connect
program,
which
is
on
our
solo.
I
o
bumblebee
github
container
registry
and
then
I'm
just
going
to
pull
the
the
b
version
from
the
cli
so
that
I
pull
down
the
version.
That's
not
necessarily
a
requirement.
A
A
A
I
guess
something
going
on
my
system
where
I'm
talking
to
one
four,
two,
two
five
one:
six,
nine
five
and
so
there's
there's
two
tables
here,
because
there
are
two
maps
that
are
being
watched,
I
guess
by
b,
so
this
top
one
is
an
advanced
ring
which
is
really
using
the
ring
buffer
bpf
map,
and
so
this
doesn't
have
the
value
right,
because
this
is
just
essentially
a
stream
of
events.
A
So,
as
connects
happen,
you
know
we'll
just
output
them
here
and
again,
the
the
the
formatting
comes
from
the
types
that
are
represented
in
the
maps
right
so
again,
I've
only.
We
only
have
bpf
code
for
this,
and
all
of
this
is
inferred
from
that.
Essentially,
and
then
the
hash
is
kind
of
what
I
was
talking
about
in
the
slides
where
this
is
actually
counter.
So
this
counter
will
you
know
this
will
keep
track
of
of
the
count
of
events
as
they
come
in.
A
A
I
guess
I
did
that
seven
times
right
and
then
so
that
that's
again,
you
know,
all
I
did
was
be
run
and
then
pull
down
the
image
right
so
that
that's
one
of
the
things
that
hopefully
kind
of
makes
it
easy
to
share,
because
you
know
you
could
also
do
this
internally
with
folks
on
your
team,
using
your
internal
registry
whatever
and
then
the
other
thing
that
I
can
show
really
quickly.
A
But
if
I
go
to
prometheus
that
I
have
running
on
the
system,
let
me
make
sure
that
I
have
the
targets
sucked
up
yeah.
So
this
is
just
running
locally
and
it's
pointing
to
the
metrics
endpoint
of
my
runner.
So
you
know,
while
I'm
running
this
and
you
know
getting
data
here
in
the
ui
or
whatever,
I
can
also
get
the
mesh
the
data
as
a
prometheus
metrics.
A
A
All
right,
so,
if
I
look
at
the
hash,
this
will
be
essentially
in
tune
with
what
we're
seeing
here
right
and
you
can
build
graphs
and
so
on,
and
then
one
of
the
things
I
guess
we
have
a
little
bit
of
time
left.
You
know
we
can
try
and
do
some
live
coding.
What
I
can
do
is,
basically
you
know
we
could
just
the
show.
I
guess
let's
go
ahead,
and
so
this
is
actually
the
exact
example
that
I'm
running
here
so
from
a
code
perspective.
A
This
file
is
really
it.
You
know
116
lines
of
vpf
code
and
that's
it
that
just
gets
built
into
the
program
and
then
everything
else
kind
of
taken
care
of
for
you.
This
is
the
the
maps
that
we
were
talking
about
or
sorry,
not
this
one.
You
can
see
that,
so
this
is
dot
maps.
This
is
standard
bpf
map.
There's
nothing
special
about
this.
This
is
just
used
for
kind
of
accounting
right
in
in
the
actual
code.
A
The
actual
ones
that
we
care
about
are
the
ones
that,
at
least
from
the
b
perspective,
are
have
the
you
know
the
dot
counter
suffix.
A
Basically,
if
you're
using
a
ring
buffer
or
any
kind
of
streaming,
essentially
we
don't
track
the
values
here,
but
we
do
have.
We
do
actually
export
that
as
metrics.
So
if
I
were
to,
you
can
see
that
I
actually
have
another
metric
for
events
ring.
So
I'm
actually
also
getting
counter-based
metrics
for
the
ring
buffer
as
well,
but
anyway
so
going
back
to
the
code.
So
you
know
this
is
my
kind
of
accounting
structure.
A
D
A
D
As
we're
running
out
of
time,
I
just
want
to
make
sure
I
understand
what
I'm
seeing
so
at
a
at
a
high
level.
This
is
is:
is
it
a
true
statement
that
you're
you're
targeting
interactive
development,
workflows
or
or
iterative?
You
know
exploratory
workflows
like
I
noticed
the
the
ui
that
looks
a
little
bit
like
canines.
You
know
sort
of
like
curses.
D
Is
that,
like
one
mode
to
write
this,
and
then
you
know
you,
you
would
foresee
be
being
used
from
the
context
of
other
projects
or
code
that
you
know
we're
able
to
leverage
this
distribution
mechanism
for
the
bpf
stuff
ppf
proportions
around
updates,
but
it's
embeddable
or
is
this?
Is
this
really
focused
as
an
interactive
sort
of
debugging
diagnostic
scenarios.
A
Yeah,
that's
a
great
question.
I
would
say
that
primarily
right
now
it
would
be
more
iterative,
interactive
style.
You
know
it
really.
I
would
say
it's
debugging,
but
I
would
say
even
more
so
it's
iterative
learning,
ebpf
and
actually
writing
vpf
code,
because
you
know,
if
you
want
to
kind
of
you
know,
track
a
new
piece
of
data
essentially
from
the
kernel
structures.
A
This
is
a
quick
way
of
getting
feedback
where
all
you
have
to
do
really
is
add
a
new
field
to
your
struct
and
you
know
populate
it
with.
However,
you
want
in
your
code
in
your
bpf
code,
you
don't
have
to
worry
about
building
that
into
the
like,
exposing
it
as
data
whatever
you
want.
It's
really
quick
feedback
cycle.
As
far
as
actual
development
goes,
I
think,
looking
forward
the
actual
distribution,
you
know,
one
of
the
things
that
you
could
do
is
one
of
the
things
that
you
know.
A
Solo
we've
had
success
with
is,
for
example,
with
wasm
passing
around
wasm
filters
for
envoy
as
oci
images.
So
the
oci
image
aspect
is
another
really
interesting
component
as
far
as
distribution
of
artifacts,
and
so
you
know,
this
could
potentially
open
the
doors
for
distributing
bpf
programs
purely
as
the
programs
in
kind
of
a
you
know,
more
cloud
native
way.
If
you
will
right
sure,
so
I
think
I
think
the
road
map
is
still
a
little
open-ended
and
it
really
depends
on
kind
of
the
user
feedback
we
get
so.
A
You
thank
you,
my
only
my
last.
D
Question
is
you
know
for
folks
here
or
for
folks
that'll
watch
us
later.
If
folks
are
interested
in
contributing,
where
should
they
reach
out
or
or
maybe
you
could
talk
briefly
in
the
remaining
time,
you
know
about
you,
what
are
areas
where
you're
actually
seeking
contribution,
or
are
you
more
seeking
feedback
like?
What
are
your
aims
in
terms
of
community
engagement.
A
At
this
time
for
the
bumblebee
project-
okay,
yeah
great
question-
maybe
I'll-
take
stab
it
and
then
lynn,
if
you
want
to
add
some
thoughts
as
well
to
that
one.
So
if
you're
interested
come
check
us
out
on
github,
I
think
we
have
the
links
in
the
notes
and
if
not
it's
just
solo,
I
o
solo.
I
o
slash
bumblebee.
A
We
have
a
handful
of
issues.
Contributions
are
welcome.
Feedback
is
very
very
welcome.
So,
if,
if
you
think
that
there's
a
use
case
that
that
you
know
this
would
help
with
please
let
us
know,
we
also
have
a
slack
that
you
can
join
that
there's
a
link
on
the
read
me
really
just
you
know
right
at
this
point.
Any
thoughts,
comments,
feedback
issues,
prs.
Everything
I
think
is
welcome
at
this
point,
lynn,
maybe
you
can
give
a
more
concise
message.
C
Totally
agree
with
you
so
check
out
bumblebee.I,
oh
by
the
way
I
sent
you
the
slack
message.
We
have
that
website
in
english
and
also
chinese,
because
one
of
our
contributors
helped
us
translate
to
chinese.
So
in
from
bumblebee.io,
you
will
be
able
to
join
our
slack
and
directly
to
the
bumblebee
channel.
So
that's
where
you
can
have
discussions
the
feedback,
such
as
how
is
you
guys
different
from
cloudflare
ebpf
exporter?
Those
are
really
interesting
to
us.
C
Certainly,
we
welcome
your
contribution
in
any
type
of
format,
whether
it's
you
know
produce
education
material
for
us.
If
you
think
this
is
a
great
for
learning.
Ebpf
to
you
know
attending
our
workshop,
which
we're
going
to
have
our
first
workshop
at
solo
count
to
teach
people
ebpf
through
bumblebee
or
submit
pr
like
lauren,
said
right.
Github
issues,
open
issues
submit
pr
just
engage
with
us.
We
would
really
appreciate
this
so
the
way
I'm
thinking
bumblebee
is
I
just
to
add
what
laura
and
matt
to
your
question.
C
You
know
a
easy
way
to
think
about
it.
Think
about
daca
right.
It's
what
darker
cri
brings
to
you
to
help.
You
build
darker
images
to
help
you
publish
that
images
to
the
registry
and
to
help
your
friends,
your
co-workers,
to
be
able
to
reuse
your
images,
that's
the
vision
we
set
for
bumblebee
for
ebpf.
C
D
Are
there
any
other
questions
at
some
point?
We'll
get
kicked
off
because
zoom,
but
thank
you
for.
C
D
Okay,
well,
I
guess,
if
there's
nothing
else
with
that,
thanks
for
attending
and
find
us
at
tag,
observability
on
cncf
slack
reach
out
directly
or
see
you
in
github
issues
thanks.