►
From YouTube: Fluent Bit V2.0: Unifying Open Standards For Logs, Metrics & Traces - Eduardo Silva & Anurag Gupta
Description
Don’t miss out! Join us at our upcoming event: KubeCon + CloudNativeCon Europe 2023 in Amsterdam, The Netherlands from April 17-21. Learn more at https://kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects.
Fluent Bit V2.0: Unifying Open Standards For Logs, Metrics & Traces - Eduardo Silva & Anurag Gupta, Calyptia
Fluent Bit is the next-generation tool to deliver a unified layer for Logs, Metrics, and Traces. In this session, Fluent maintainers will do a 101 intro to the observability space and also will do a deep dive into the new features available in Fluent Bit v2.0 . Attendees will benefit from this session by learning different techniques for observability associated with Fluent Bit, Prometheus, and OpenTelemetry, as well as a couple of tips and best practices that are a must when deploying observability tools in production.
A
A
Well,
my
name
is
Gerardo
Silva
and
together
with
a
anurac
who's,
also
my
internal
fluid,
and
we
were
really
happy
about
this
announcement.
I
know
that
you
see
this
some
kind
of
news
this
morning
and
the
the
goal
of
this
session
is
to
give
you
a
very
quick
intro
to
the
project,
because
we
don't
have
so
much
time
a
quick
update
about
what's
going
on
and
a
quick
demo
if
we
have
enough
time
for
that,
so
we
represent
ourselves.
You
can
follow
us
on
GitHub,
Twitter
and
well.
A
First
of
all,
one-on-one
right
so
fluent
bit
is
part
of
the
flu
in
the
family
project
and
both
solve
one
of
the
problem
that
is,
move
data
from
one
place
to
the
other.
That's
basically
how
it
started
right,
but
in
the
middle
we
can
do
processing
data
reduction
and
a
bunch
of
things
that
maybe
you
are
already
aware
of.
Both
projects
are
graduated
with
the
cncf
right.
A
I,
think
that
when
flu
and
bit
we
have
followed
the
same
pattern
right,
no
matter
what
is
coming
out
in
the
in
the
industry.
If
there's
a
new
standard,
we
are
going
to
jump
and
support
it.
Why?
Because
the
users
need
it
right
and
yeah,
and
that's
how
we
are
have
evolved
the
project?
A
lot
with
different
type
of
Integrations
and
fluent
is
all
about
open
source,
but
observability,
and
that
is
really
important
is
to
provide
the
avoiding
the
bend
or
lock-in
for
users
right.
A
It's
normal
that
when
you
go
and
you
buy
a
solution,
because
your
goal
is
not
to
deploy
an
agent
right,
nobody
likes
deploying
agent
besides
me,
but
besides
that
right,
you
choose
a
Splunk.
You
choose
elastic
whatever
you
want,
but
at
some
point
after
one
year,
two
years
or
in
the
middle,
you
would
just
want
to
use
one
packet
and
maybe
switch
to
another
and
to
gain
more
control
over
your
data.
A
That's
what
we
call
the
vendor
lock-in
vendor
lock-in
is
when
the
vendor
that
you're
paying
for
services
locks
you
in
into
their
own
solution,
and
it
will
be
very
complex
for
you
to
get
out
of
it
sometimes
takes
more
than
a
year
right.
So
the
whole
thing
about
fluent
and
many
other
projects
in
the
ecosystem
is
about
give
you
this
freedom
and
flexibility
to
say.
Okay,
today,
I'm
using
this
vendor,
but
since
I
use
this
project
like
fluent
I,
can
decide
where
my
data
will
go.
A
Okay
and
it's
project
and
product
platform,
agnostic
who
use
this
well
and
if
you
go
to
jkg
Google
Cloud
deploy
a
kubernetes
cluster.
Where
you
go
to
Ikeas
on
Amazon,
you
will
see
that
fluent
bit
is
running
by
default.
In
there
there
are
millions
and
million
deployments
of
flu
and
bit
every
single
day,
and
where
are
we
going?
Everything
is
started
with
fluency
and
we
are
from
the
same
family,
but
fluency
was
really
hard
to
to
make
it
scale
even
more
from
what
was
doing
at
the
moment.
Mostly
the
major
technical
challenges.
A
A
That
is
not
scary
enough
right
and
that's
what
one
of
the
reason
why
flu
and
bit
was
born
well
originated
for
embedded
Linux,
but
then
started
evolving
as
a
cloud
native
solution
and
we
we
are
part
of
the
same
family,
same
project,
and
we
say
that
most
of
the
Innovation
is
happening
now.
Influented
and
one
of
the
trends
is
a
cloud
providers
like
Amazon,
Microsoft
and
Google
has
migrated
from
fluency
to
fluent
bit
in
the
highlights.
A
Well,
production
grade
is
really
high
performance.
Maybe
you
don't
know,
but
when
beat
is
written
in
C
language
yeah,
unsafe
memory
yeah,
you
can
say
all
of
that,
but
it
runs
and
it's
killed,
and
that
is
the
good
thing
you
can
develop
on
any
language.
So
in
any
language
you
can
do
things
slow
or
fast,
right
or
buggy
right.
A
The
thing
is
that
if
you
have
the
best
practices
to
avoid
situations
like
memory
Corruptions
or
you
know,
having
not
free
in
memory
when
it
needs
to
be
done,
yeah,
if
you
put
all
the
best
practices,
you
will
be
fine
and
I
think
I
need
the
project
over
the
years.
We
have
learned
about
all
these
practices
and
there's
a
team,
their
Cloud
providers,
contributing
to
the
project.
So
every
year
it
gets
more
strong
and,
of
course,
low
resource
consumption.
A
Everybody
when
develop
applications.
Now
nobody
thinks
about
memory
and
I
think
that
that
is
a
bad
practice.
Well,
I'm
a
kind
of
old
school
and
in
Old,
School,
I
think
about
memory.
How
much
memory
this
component
is
going
to
use,
and
maybe
I
can
reuse
this
a
bunch
of
memory
before
trying
it
out
to
release
it
and
relocate
it
again.
This
kind
of
optimization
exists
in
fluembit
and
flu
and
bit
can
be
retrieved
and
consumed
from
different
places.
A
You
can
use,
of
course,
feel
follow
the
Upstream
releases
flame
bit
Upstream
a
new.
A
new
minor
version
is
released
every
two
weeks
right,
but
if
you
want
to
run
in
a
more
long-term,
stable
way,
there
are
distributions
of
fluent
weight
that
are
based
on
that
Upstream.
But
they
are
supported
like
the
AWS
for
fluent
build
a
quality
for
fluent
bed
and
Google
OPS
agent,
which
we
will
use
for
their
own
customers,
and
you
can
get
the
container
images
packages
for
deviant,
Red,
Hat,
Rocky,
Linux
or
any
kind
of
new
fancy
distribution
around
even
center.
A
Six
I
think
you
will
not
imagine
how
many
people's
Running
Center
Six,
okay,
so
flu
and
bit
as
I
said
at
the
beginning.
It's
all
about
to
move
data
from
one
place
to
the
other,
and
you
will
think
that
the
concepts
that
we
have
are
sources
or
inputs
and
in
the
other
side,
are
destinations.
How
flowing
bit
connects.
Everything
is
about
the
concept
of
plugins.
A
So
internally,
we
Implement
a
plugin
to
understand,
for
example,
a
metadata
from
kubernetes
how
to
scrape
data
from
Prometheus
how
to
receive
data
from
applications,
sending
open,
Telemetry
data
or
just
metrics
from
the
Linux
system.
That
is
running,
so
it's
very,
very
subtle
and
flexible
to
get
data
locally
or
remotely,
and
the
same
concept
applies
for
the
output
side.
A
What
I
didn't
mention
here
is
about
the
filters,
so
in
the
middle
you
can
do
filtering,
which
means
a
capacities
to
modify
the
records
or
enrich
your
data
or
just
drop
data.
That
follows
a
pattern
that
you
are
not
interested
in
and
where
we
are
today.
This
is
crazy
and
and
I
say
crazy,
because
in
when
you
start
a
project-
and
you
start
getting
a
few
Docker
Hub
pools
right
well.
This
is
starting
on
2016
right
this,
but
we
just
started
the
container
on
2019.
A
and
you
see
that
during
this
year
we're
getting
more
than
2
billion
downloads.
That's
a
lot,
and
what
that
means
is
a
lot
of
responsibility
for
the
maintainers
and
companies
that
contribute,
but
also
you
get
more
enhancement
requests
you
get
more
back
requests
a.
We
have
more
bucks
because
you
found
a
many
other
kind
of
a
use
cases,
so
the
trends
is
like
this
year.
Everything
is
going
up
and
I
I,
don't
know
in
total,
it's
more
than
three
billion
CNC.
A
It
just
did
a
book
blog
post
about
that
and
well
we're
really
happy
about
this.
But
it's
a
huge
responsibility,
so
I'm
sure
that
everybody
who's
here
will
contribute
to
the
project
also
to
make
it
more
healthy
in
general
Investments
in
this
year
we
have
done
all
the
Telemetry
signal.
Support
flowing
bit
was
originally
just
shown
for
to
support
blocks,
but
then
we
expanded
to
support
metrics
and
support
traces
right.
That
means
that
we
support
the
native
payloads.
We
added
TLS
TLS
support
for
the
input
plugins.
A
We
have
a
new
cool
feature
called
tap
tap.
We
it
does
solve
one
of
the
problems
that
many
users
had
they
said.
Fluimbit
is
working
I'm,
seeing
my
data,
but
sometimes
the
format
of
my
data
is
not
as
I
was
expecting
after
I
query,
elastic
or
after
a
query
is
blank,
so
they
say
the
only
way
to
troubleshoot
that
that
sorry
is
to
stop
flowing
bit
right
and
try
and
stdl
plugin
and
try
to
dig
what
is
going
on
and
then
I
can
start
it
again
on
start,
and
you
know
they
got
into
that
cycle.
A
So
that
is
a
future
that
now,
if
you
enable,
of
course
over
an
HTTP
request,
you
can
tell
fluid
hey
open
for
me
a
tap
session
and
send
me
in
a
couple
of
seconds
the
data
that
is
flowing
through
this
input.
Plugin
just
send
me
some
samples
and
then
that
session
get
destroyed.
So
you
can
inspect.
What's
going
on.
You
know
a
internally,
of
course,
you're
not
going
to
enable
tap
to
the
public
internet.
A
It
will
run
inside
your
cluster
security
right,
but
it
is
that
after
you
hold,
you
handle
it
and
all
the
requirements
that
we
got
is
like
has
like
a
storage
engine.
It's
not
like
a
database,
but
it
allows
you
to
store
data
either
in
memory
either
in
file
system,
depending
on
how
you
want
to
handle
the
load
and
ruin
that
internal
metrics
did
not
expose
the
storage
Matrix.
Now
you
can
flow
those
metrics
as
part
of
the
pipeline.
A
Okay,
so
looks
meters
and
traces.
This
is
all
about
this
release
and
Lux
has
been
there
since
the
beginning.
We
support
unstructured
data
structure,
is
schema
less
and
we
support
processing
like
filtering
and
enrichment
of
data.
You
have
seen
this
from
the
beginning
from
The
Matrix
side.
We
support
the
standards
of
open,
metrics
and
open
Telemetry
right.
A
All
of
this
is
about
a
defined
schema
and
we
support
different
Matrix
types
like
counter
gauges,
histograms
summaries,
whatever
you
have
right
now,
and
the
good
thing
is
that
when
we
say
support
Matrix,
not
just
Prometheus
and
open
Telemetry
at
the
moment
that
fluid
gets
metrics
inside,
we
can
even
send
those
metric
to
splank.
We
can
send
those
method
to
influx
CV
right.
So
this
is
one
of
the
values
of
this
implementation
that
keeps
being
agnostic
and
be
able.
It
provides
you
with
flexibility,
to
connect
to
different
endpoints
and
endpoint
types.
A
In
the
Prometheus
side,
we
try
to
replicate
and
integrate
different
specific
features.
For
example,
I,
don't
know
if
you're
familiar
with
node
exported
Matrix,
which
is
a
prey
from
Prometheus
in
conversation
with
the
team.
We
come
up
with
idea
a
why
we
don't
implement
the
same
functionality
but
inside
flow
embed.
A
An
open
Telemetry
today
we
are
announcing
with
fluent
b2.0
support
for
logs
metrics
and
traces,
fully
supported.
I
know
you
will
have
a
lot
of
questions
at
the
end,
so
we'll
be
happy
to
answer
all
of
that,
and
if
you
don't
have
enough
time
here,
we
can
go
to
the
hall
and
cider
okay
performance
improvements.
A
one
of
the
also
the
challenges
is,
like
you
know:
35
more
data
every
year,
I'm
tailing
files,
but
I
now
have
more
load
and
fluent
bit
from
the
beginning.
A
It
was
running
just
in
a
single
process
mode,
but
it
was
really
efficient,
but
year
over
year
people
say
Hey.
You
know,
I
have
like
96
core
in
my
machine
and
you're
using
one
good
enough.
Okay,
we
implemented
threading
for
the
output
plugins,
so
now
adopt
plugins
are
doing,
processing
or
encoding.
The
data.
All
of
that
happens
is
separate,
CPU
cores.
Now
we
did
the
same
for
input
plugins,
but
you
have
to
enable
that
feature.
A
A
You
might
want
to
mask
that
information
or
there's
any
social
security
number,
and
you
want
to
perform
some
action
if
that
data
comes
in
influent.
As
of
yesterday,
we
provided
Lua
filters,
so
filters
with
a
Lewis
scripting
language
that
you
can
write
your
own,
your
own
rules
and
take
some
decisions
on
that,
and
today
we
are
expanding
that
with
webassembly.
A
If
you're
not
familiar
with
assembly,
it's
like
a
new
trending
thing
that
allows
you
to
write
a
code
in
many
languages
like
rust
or
C,
plus
or
Titan,
and
generate
some
kind
of
byte
code
like
a
unique
specification
that
can
run
some
fluent
bit.
So
you
are
no
longer
restricted
to
see
you're,
not
that
longer
restricted
to
Lua.
B
B
Okay,
yeah
so
yeah.
What
we're
going
to
do
is
show
you
an
architecture
of
how
this
all
works
together
with
fluentbit
2.0,
we're
also
going
to
show
Jaeger
grafana
for
visualization
and
then
all
of
this
running
Trace
application
underneath
so
an
application.
It's
generating
a
lot
of
good
open,
Telemetry
data,
great
schema
of
firing
off
that
data,
we're
collecting
with
fluentbit
and
we're
firing
it
off
to
the
open,
Telemetry
collector
and
we're
firing
it
off
to
Jaeger
as
well.
B
So
if
I
go
ahead,
I
can
just
show
you
the
docker
desktop
that's
running
here,
and
this
just
shows
you,
the
containers
and
apps
I
have
all
of
this
is
open
source
by
the
way.
So
you
can
try
it
out
here
as
well.
You'll
see
our
Flint
bit
demo
app.
We
have
fluent
bid.
That's
now
running
the
2.0
version,
Jaeger
Prometheus,
the
collector
grafana
and
Vivo
just
so,
we
can
quickly
visualize
the
data.
B
So
if
I
go
ahead
and
go
into
a
grafana
dashboard,
you
know
the
same
experience
that
you
might
be
used
to
and
and
be
using
we're
having
fluent
firing
off
this
data
from
a
metric
site
over
to
Prometheus,
and
here
we
are
collecting
those
metrics
and
visualizing
it
with
with
the
dashboard.
So
what
does
that
really
start
to
enable?
Is
we
don't
want
to
have
you
continue
switching
all
these
tools?
Why
can't
we
just
plug
into
all
of
the
ecosystems,
workflows
tools
and
open
source
standards
that
you
might
already
have
in
place?
B
The
next
is,
with
the
Jaeger
side,
we're
just
firing
it
off
to
Jaeger,
with
all
the
open,
Telemetry
support
that
awesome
team
has
been
been
adding
over
there.
We
can
quickly
go
ahead
and
take
that
same
service.
Look
at
the
spans
again.
This
is
a
really
simple
I.
Think
it's
a
JavaScript
thing.
That's
firing
off
Telemetry
spans
over
over
time.
B
Now.
This
is
this
feature
set
is
something
where
we've
tried
really
hard,
also
to
make
sure
that
the
experience
of
setting
it
up
doesn't
mean
that
you
have
to
have
intense
knowledge
about
the
underlying
protocols
and
how
everything
works.
You
really
just
set
a
port
up
and
from
there,
depending
on
the
data
type
that
was
being
fired,
we're
able
to
grab
that
take
it
for
an
internal
conversion
and
then
fire
it
off
to
the
expected
output,
whether
it's
Prometheus
otel,
Jaeger
Etc.
B
The
last
thing
I
want
to
show
is
one
of
the
the
kind
of
top
features
that
have
always
been
requested
from
our
side
of
hey
I'm
running
this
on
thousands
and
thousands
of
servers,
I'm
not
sure,
what's
happening,
data's
not
flowing,
how
can
I
go
and
make
sure
that
the
data
that's
being
sent
is
is
correct,
and
this
is
a
feature
we
call
tap
now
tab
I'm
going
to
go
ahead
and
open
up.
My
terminal
here.
B
Awesome:
okay
and
then
what
we're
going
to
do
is
run
fluentbit
V2.
With
this
new
Option
called
Dash
Z
Now.
What
Dash
Z
is
going
to
do.
Is
it's
going
to
allow
us
to
make
an
HTTP
request
to
the
running
fluid
bit
to
say:
hey
flim
bit.
What's
going
on
at
this
particular
plug-in,
I,
don't
know,
what's
happening,
something's
not
functioning
correctly.
I
want
to
start
to
debug
and
understand.
B
What's
what's
happening
now,
if
we
go
into
this
other
tab
to
go
ahead
and
make
a
request,
we
can
run
a
pretty
simple
curl
command
and
the
plugin
I'm
running
is
called
dummy.
It
just
generates,
as
you
saw
a
message
dummy
every
single
second
I'm,
going
to
run
this
command.
It's
going
to
say:
okay,
Flint
bit
says:
okay,
I've
been
instructed
to
now
go
and
instrument.
All
of
those
specific
dummy
filter.
Plugins
now
say
you
have
a
hundred
filters.
B
You
can
actually
choose
the
very
specific
filter
or
plug-in
that
you
want
to
go
instrument
and
enable,
and
then
we
will,
on
the
other
screen,
will
print
out
all
of
those
all
of
that
information
for
you.
So
you
can
see
the
exact
payload.
That
is
there
right,
so
you
have
to
enable
this.
So
it's
not
like
this
is
enabled
by
default
and
anyone
can
access
anything
in
in
your
pipeline.
B
Two,
there
are
limitations
or
settings
you
can
put
in
with
how
big
a
payload
you
want
for
a
specific
amount
of
time
and
and
really
quickly
start
to
look
at
this
information
coming
in,
live
and
say:
that's
why
I
got
a
http
400
air.
That's
why
my
filter
is
not
showing
up
a
little
bit
easier
to
do.
Things
live
which
I
always
am
surprised
with
right,
debug
in
production
and
then
last
but
not
least,
just
kind
of
on
the
visualization
side.
B
You
know
if
we
want
to
you
know,
look
at
what's
happening,
you
can
fire
it
off
to
say
a
live
data
viewer,
and
this
is
one
of
one
of
the
open
source
projects
where
you
just
dump
data
in
you
can
start
to
visualize
it.
So
with
that
it's
a
kind
of
overview
of
flipit
V2
architecture
of
how
we
send
data
to
all
of
the
different
open,
Telemetry
sources,
logs
metrics
traces.
We
showed
a
little
bit
about
tap
for
more
operational
debugging
with
that
I
think
we'll
have
plenty
of
time
here
for
additional
questions
but
yeah.
C
B
C
B
Think
three
three
considerations
scale
for
sure
when
running
on
kubernetes
container
density
goes
up
more
logs,
maybe
network
devices
security
devices
generating
more
traffic.
Great,
that's
one
consideration
when
you
want
you
might
want
to
switch.
Two
is
if
you
want
to
do
some
more
of
those
enrichments
redactions
things
with
wasam
or
Lua,
there's
a
lot
of
inbuilt
functionality
there
for
like
showing
and
stuff
like
that,
and
last
but
not
least,
is
you
start
to
have
constraints
with
resources
like
maybe
your
environment
shrinks
or
Things
become
a
little
noisy
having
that
capability?
D
Thank
you
guys,
so
we
are
running
fluent
D
not
fluent
bit
yet
and,
like
you
said,
no
need
to
upgrade.
I
have
seen
like
you.
You
are
sending
logs
to
Prometheus
as
well
from
fluent
big
right
now
we
are
running
a
not
exporter
and
I.
Think
it's
a
Prometheus
black
box.
So
what's
an
advantage
of
using
fluent
bid
instead
of
using
just
the
Prometheus
node
exporter
and
the
Black
Box
great.
B
Great
question
for
I'll
say
that
almost
the
same
almost
same
answer:
if
it's
working
with
node
exporter
no
reason
to
to
switch
it
out.
What
we
find
is
sometimes
folks
will
say:
I
want
to
capture
host
level
metrics,
but
I
don't
want
to
run
a
node
exporter,
and
that
was
the
main
draw
of
folks
who
are
saying:
hey,
I'd,
love
to
scrape
the
data
I
don't
want
to
have
to
install
another
or
manage
multiple
agents
right.
Managing
agents
is,
is
not
the
the
fun
thing
of
of
anyone's
role.
B
A
Something
to
add
on
node
exporter
in
general
is
a
great
project,
but
we
found
that
many
users,
for
example,
has
a
cluster
like
a
hundred
nodes
and
if
node
export,
that
is
using
15
megabytes,
20
megabytes
multiplied
by
the
amount
of
you
know
nodes.
Sometimes
they
say:
hey
I,
don't
want
to
waste
that
amount
of
memory
from
a
cluster
perspective
versus
some
kilobytes
influent
bit
for
the
same
functionality.
That's
one
of
the
Twitter.
A
E
All
right,
thank
you.
I
you
mentioned
you
added
the
two
languages,
support
wa
and
go
long,
I'm,
not
very
familiar
with
the
wa
but
I'm
a
long
developer,
so
I'm
wondering
that
what
dependencies
dependent
packages
that
you
natively
support,
let's
go
along
can
I
add
the
dependent
package
as
I
want,
or
what
was
the
limitation
of
that
language
support.
B
B
Good
question:
so,
if
you're
going
to
use
light
so
with
wasam
and
go
if
you're
going
to
use
specific
libraries
from
either
of
those
languages,
you'll
typically
need
those
as
a
dependency
similar
to
like,
say
Lua.
We
include
the
Lua
jit
library,
but
if
you're
going
to
do
some
luxml
or
some
other
Library,
you
need
to
have
those
as
part
of
the
the
initial
package
with
wasam
and
the
go
input
plugins.
Those
are
the
those
are
the
same
dependencies
that
we
have
with
the
package
today.
B
E
F
B
B
There
yeah
there's
there's
a
couple
GitHub
issues
so
folks
in
the
community
say:
hey.
We
really
want
file
system
with
this
specific
metric
that
we've
skipped
over
okay,
great
but
I.
Think
those
are
the
things
that
we're
really
looking
for
from
the
community.
Also
to
say:
hey,
look.
We
want
XYZ,
here's
also
what
we
want
Windows
metrics
Windows
exporter,
and
that
really
helps
to
for
us
to
build
out
a
robust
roadmap
and.
F
B
A
One
other
use
case
that
came
up
is
with
all
these
open
telemetries
thing.
Some
users
said:
hey
I'm,
using
this
x
provider
or
vendors
with
an
open,
Telemetry
endpoint,
but
I
want
to
collect
my
Matrix
with
node
exporter
right
with
no
exported
a
launch.
You
cannot
do
it
because
you
might
need
the
Prometheus
exporter,
Plus,
open
television,
television
collector
to
do
some
processing
and
send
it
out.
But
if
you
have
flu
embed,
you
just
can
do
not
exported
style
locally
and
fire
off
the
data
to
open
Telemetry
metrics
directly.
G
B
H
Hey
So:
currently
we
have
a
log
stash
to
scrape
the
metrics
script,
the
Kafka
event
and
we
send
it
to
open,
search
and
elasticsearch.
Do
you
foresee
or
do
you
have
any
I
mean?
Do
you
think
the
fluent
bit
can
support
that
kind
of
even
scraping
from
Kafka
and
send
it
to
any
of
our
log
any
of
the
logging
Solutions
yeah.
B
Good
good
question:
we've
had
a
Kafka
input
issue
for
for
a
while.
We
actually
did
a
small
POC
with
the
with
the
single
threaded
input
model
and
it
was
a
bit
slow
for
for
what
we
feel
comfortable
with
with
the
new
input
threaded
interface
in
V2,
we
can
perform
that
at
a
much
much
higher
and
faster
Cadence,
so
actually
for
Kafka.
We
use
already
Kafka
out
on
on
the
output
side
and
that
works
really
really
well.
There's
a
good
presentation
by
LinkedIn
on
Monday
at
open
observability
day.