►
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
Hello,
everyone
thank
you
for
having
me
here,
I'm
jean
luca
and
I
work
as
a
developer
in
the
past.
I
work
as
a
sre
as
a
reliability
engineer
and
I'm
a
lot
involved
with
cloud
computing,
kubernetes
and
stuff
like
that
today,
I'm
here
to
speak
with
you
about
observability
and
with
a
project
in
mind
that
is
called
open
telemetry.
So
this
is
what
we're
gonna
look
at
today.
A
So,
let's
start
from
something
more
general
about
pros
and
cons
about
cloud
computing,
kubernetes
and
microservices.
So
what
those
have
in
common
and
what's
good
and
what's
bad
about
those
there
are
both
of
them.
They
have
a
lot
of
good
stuff.
They
bring
a
lot
of
good
stuff
to
us
and
that's
why
they
are
so
popular,
so
cloud,
computing
and
kubernetes
gives
you
an
api
that
you
can
use
programmatically
to
build
automation
and
to
deploy
your
application.
A
A
That's
way
different
when
you
have
to
replicate
that
across
like
cloud
providers
or
across
like
regions
or
continents.
So
this
this
distribution
makes
stuff
way
harder
and
more
distributed.
You
are
more
complicated,
it
is,
and
cloud
computing
and
kubernetes
makes
the
distribution
way
simpler,
way
more
affordable
and
that
increased
complexity.
A
Microservices
is
a
way
you
write
application
to
make
them
to
scale
not
only
the
application
itself,
but
also
the
teams
that
work
on
your
product,
because
you
can
have
smaller
team
that
works
on
a
segmented
piece
of
your
application
or
your
business,
and
they
can
work
by
themselves
and
you
can
scale
them
up
and
down
as
you
wish
them.
So
it
gives
you
way
more
control
and
scalability,
but
it
also
means
that
you
have
a
lot
more
to
manage
at
what
you
are.
A
Usually
you
know
you
usually
have
to
take
care
when
you
have
one
gigantic
application,
so
I
think
we
can
summarize
pros
and
cons
here.
Has
you
know
you
get
better
scalability,
you
get
more
like
distribution
across
the
network,
but
that
has
a
price
and
the
price
is
all
about.
How
do
you
manage
and
how
do
you
understand
what's
going
on
in
your
system?
A
A
I
know
you
don't
have
this
question
when
you
have
a
single
like
replicas
or
when
you
have
a
single
data
center,
and
so
when
the
distribution
is
lower
because
yeah,
if
it
goes
down,
go
down,
that's
a
problem
because
it's
easy
to
maintain
like
it's
a
con,
because
usually
you
want
to
keep
everything
up
and
running
all
the
time.
So
this
is
kind
of
the
friction
that
you
have
when
you
think
about
onboarding
kubernetes
cloud
computing.
A
I
also
never
heard
like
a
customer
complaining
about
my
application
using
too
many
cpus
like
when
I
get
ticket
supports
for
e-commerce.
That
says
that
they
can
pay
or
that
the
page
doesn't
load
fast
enough,
but
nobody
ever
complained
about
cpus
but
from
mine.
From
my
experience,
everybody
cares
about
cpu
I
mean
when
I
go
in
a
company.
A
I
see
graphs
and
dashboards
all
about
cpu
packet
lost
and
all
those
stuff
that,
like
customers,
really
don't
care
about
because
they
come
from
a
different
perspective,
and
this
is
part
of
the
story
that
I
want
to
tell
like
those
metrics
cpu
memory
are
important,
but
the
business
requires
other
metrics
and
as
a
developer,
we
are
there
to
meet
their
expectation,
so
we
have
to
figure
out
a
way
to
make
this
to
work.
So
customers
doesn't
complain
about
the
quality
of
my
code
either.
A
I
can
wrote
the
words
code
that
works
as
like,
very
good,
and
they
are
happy
or
I
can
write
the
perfect
code
that
doesn't
meet
their
criteria
and
they
are
not
able
to
use
the
outcome
of
my
workflow.
So
this
this
is
important.
They
don't
care
about
cpu,
they
don't
care
about
code
quality,
they
care
about
the
product
to
be
up
and
running,
reliable
and
useful
for
them.
But
I
care
about
those
stuff
as
a
developer,
because
for
me
the
consequence
of
about
writing
good
code
that
is
reliable.
That
is
easy
to
maintain.
A
That
is
that
doesn't
use
all
my
like
computer
resources
is
important
because
by
consequence
usually
means
that
the
customers
are
happier,
but
they
don't
care.
I
have
to
find
a
way
to
write
those
stuff
in
a
way
that
has
a
direct
impact
to
them,
and
one
of
the
best
way
is
to
use
the
metrics
that
they
think
that
we
think
are
important
for
the
customer.
So
if
you
think
that
the
customer
doesn't
care
about
cpu
in
your
ecommerce,
what
does
it
care
about?
A
Maybe
they
care
about
like
the
the
number
of
products
that
you
can
suggest
to
them,
or
the
number
or
the
latency
to
opening
a
detail
of
the
product.
So
all
those
metrics
has
to
be
aggregated
with
the
cpu,
with
the
memory
with
the
one
that
we
know
about
to
get
something
useful
out
of
them.
If
you
look
only
at
one,
only
at
one
signal
is
usually
like
complicated
to
to
make
it
to
work.
Usually
it
doesn't
describe
enough
the
world
that
we
are
in.
A
So
let's
take
a
break,
because
there
is
a
lot
already
here
and
I'm
going
to
give
you
a
brief
presentation
about
myself.
So
I'm
john
lucarbezano
and
I
come
from
italy.
I
live
in
touring,
work
close
the
house
in
the
north
and
I
work
at
pocket
as
a
senior
staff
sort
of
a
software
engineer,
and
you
can
find
me
around-
has
a
john
arb
I'm
on
twitter
and
I
blog
I
use
twitter
a
lot.
A
So
if
you
have
any
questions
or
if
or
you,
if
you're
looking
to
chat
about
those
stuff
like
cloud
computing,
observability
monitoring
just
see
you
there
and
when
I'm
not
developing,
I
grow
vegetables
in
my
garden.
So
this
is
the
best
season
to
see
some
pictures
about
like
tomatoes
and
potatoes,
and
so
on
so
see
you
there.
A
So
my
question
for
you
or
let's
say
the
question
I
usually
try
to
do
at
myself
when
I
design
a
system
or
when
I
code
is
how
do
I
tell
a
story
for
our
cast?
So
let's
say
that
I
let
let's
say
that
I
have
a
you
know
website
that
serves
no.
Let's,
let's
stay
straight
to
the
e-commerce,
because
it's
easy,
so
how
how
I
tell
a
story
for
a
specific
payment
for
a
customer
like,
as
we
know
the
microservices
like.
A
If
we
do
microservices,
we
have
a
lot
of
different
pieces
and
the
payment
request
goes
through
all
of
them.
Trying
to
you
know
fulfill
their
cast.
But
how
do
we
describe
all
the
story
for
a
specific
payment
or
let's
say
that
you
are
designing
a
new
feature
like
you
are
adding,
like
I
don't
know
you
are
having
like
a
comment
box,
a
way
to
leave
feedback
to
to
a
product.
A
These
will
may
involve
like
writing.
A
few
microservices
deploy
them
interact
with
some
other
microservices
that
are
already
there
like
the
metadata
database,
for
example,
and
how
do
you
tell
the
story
of
this
new
feature
from
the
outside?
So
let's
say
that
you
wake
up
tomorrow
and
nothing
works
because
something
like
is
broken.
How
do
you
look
and
trying
to
figure
out
that
that
solution?
A
So
this
question
is
very
important
and
I
do
it
during
like
code
review,
for
example,
because
that's
the
good
place
where
I
can
interact
with
myself
or
with
the
developer,
that
I'm
reviewing
the
code
for,
and
we
can
try
to
figure
out
how
to
make
that
feature
observable.
And
that's
where
observability
comes
from.
A
A
A
How
do
you
tell
the
story
of
your
request
if
you
write
like
microservices
that
come
from
different
languages
in
some
way,
you
have
to
agree
at
some
standard
at
the
end,
and
this
is
hard
so
open
telemetry
helps
you
to
do
that
so
open
telemetry
is
a
specification
that
describes
how
you
instrument
your
code
to
be
able
to
figure
out
what's
going
on
in
your
application
from
the
outside,
because
this
is
what
we
do
with
the
monitoring.
I
mean
we
open
a
dashboard.
A
A
From
your
point
of
view
from
your
desktop
and
oftentimes
telemetry
helps.
You
gives
you
specification
and
client
libraries
that
you
can
use
in
your
code
to
expose
metrics
in
a
way
that
are
the
same
across
many
languages,
because
that's
what
we
need
at
the
end
of
the
story.
We
need
the
full
story,
no
matter
which
languages
you're
using
which
cloud
provider
you're,
using
or
whatever
we
just
have
the
first.
A
We
just
need
the
full
story,
so
your
application
may
have
like
a
language,
or
at
least
it
has
a
language
that
it
speaks
and
the
language
that
the
application
speaks
is
the
one
that
you
are
able
to
teach
to.
The
application
itself
so
logs,
for
example,
are
a
language
that
their
application
use
to
tell
you
something,
and
we
are
the
the
one
writing
logs.
A
So
if
we
like,
after
a
couple
of
weeks,
get
back
to
the
logs
and
we
can't
figure
out
what
they
are-
it's
our
fault
as
a
developer,
because
we
didn't
write
code.
That
is
understandable
from
the
outside,
at
least
so
a
bunch
of
like
stuff
that
you
can
look
at
to
make
your
application
to
speak
in
a
clear
language
is
to
use
structured
logs
so
think
about
structural
logs.
Not
has
a
message
that
has
a
timestamp
but
has
a
timestamp
that
has
a
set
of
key
value
pairs.
A
Maybe
one
is
the
message
that
is
the
human
readable
one,
but
there
are
other
stuff
that
you
can
maybe
print
as
a
json
and
parse
after
that.
So
you
can
think
about
those
other
stuff
as
a
way
to
you
know
print
the
state,
the
context
of
your
application,
so
in
the
e-commerce
it
will
be
like
the
product
id,
it
will
be
the
customer
id.
A
A
This
ability
to
you
know,
enrich
your
log
with
information
that
comes
from
the
application
in
the
at
the
point
where
the
logs
get
printed.
So
the
correlation
is
an
id
that
usually
floats.
It
gets
generated
from
every
request.
Every
request
has
its
own
one
and
it
goes
through
all
the
requests
in
this
way
you
can
say:
okay,
give
me
all
the
logs
that
comes
from
the
recast
id
or
the
correlation
id
one,
two,
three
four
five
and
you
get
only
the
one
that
are
related
to
to
that
specific
request.
A
This
correlation
id
of
this
request
id
is
something
that
we
see
a
lot
when
when
we
do
traces,
I
will
tell
you
what
like
what
tracing
is
later
but
think
about
it.
When
you
open
the
the
dev
tools
on
chrome
and
you
go
in
the
network,
you
see
all
the
bars
that
represent
the
time
spent
from
the
browser
downloading
all
the
assets
that
your
page
requests
and
you
see
that
all
the
bars
have
time
and
you
can
figure
out
the
entire
picture
that
is
called
a
trace
split
by
asset.
A
This
is
a
trace
and
every
line
is
a
span
other
than
that.
Your
application
can
also
expose
events,
and
events
are
like
the
number
of
logins
or
the
number
of
products
that
a
customer
so
split
group
by
product
itself.
All
those
stuff
are
events
that
usually
you
can
see
them
as
a
counter,
so
numbers
that
goes
up
or
gauge
that
are
numbered.
That
you
know
goes
back
and
forth
and
you
can
aggregate
them
and
group
by
a
specific
key.
A
So
when
I
think
about
like
monitoring
or
infrastructure
monitoring,
I
think
about
something
like
this.
I
have
the
telemetry
generator
that
are
like
our
applications.
It
will
be
it
will,
maybe
your
application,
or
it
will
maybe
a
third
party
application
like
mysql
rabbit
and
q
or
whatever
you
send
all
those
metrics
or
to
a
collector
or
the
collector,
goes
and
takes
the
metrics.
A
Pull
versus
push
is
a
debate
that
in
monitoring
will
stay
forever.
So
that's
not
important,
but
there
is
a
collector
that
usually
applies
back
pressure
back
back
pressure
and
push
them
to
the
storage.
The
storage
is
the
place
where
your
metrics
leaves,
so
I
put
together
a
list
of
for
all
of
those
categories.
A
As
I
said,
the
telemetry
generator
is
the
easiest
one,
because
it's
everything
like
everything
that
expose
a
metrics
your
application
in
go
javascript
node.js,
whatever
the
collector
are
agents
that
usually
runs
inside
a
server
and
collects
all
the
metrics
coming
from
the
your
applications
and
push
them
to
a
storage.
There
are
collectors
open
source
like
telegraph
or
prometheus
exporter
or
open
telemetry
has
a
collector
itself.
A
Jaeger
new
reddick
has
an
agent
blog,
stash
is
an
agent
and
so
on.
The
storage
are
places
where
you
can
store
those
information.
Cassandra
is
one
influx
fluxdb
prometheus.
There
are
also
has
a
service
one
like
honeycomb
or
new,
relic
or
open
source
like
elastic
elasticsearch.
Those
are
usually
called
time
series
databases.
A
Obviously
you
can
store
those
kind
of
metrics
everywhere,
but
if
you
use
a
time
series
database,
it
is
designed
for
time
series.
Let's
say
so:
it's
a
little
bit
more
efficient,
some
of
the
technology
that
I
touched
or
that
we
will
touch
during
this
talk,
has
those
logos
I
just
pushed.
I
just
put
them
there,
because
I
think
it
will
give
you
an
idea
or
maybe
you
will
rely
on
them
like
googling
around
or
you
know,
surfing
the
net
for
those
information.
A
So,
let's
back
to
what
it
is
a
trace.
So
a
trace
looks
like
this.
So
it's
like
the
traces
of
is
the
full
picture,
and
you
see
at
the
left
that
there
is
a
column
with
a
bunch
of
ips
and
those
are
the
services
that
you
have
in
your
microservices
environment
and
every
span
that
is
the
bar
is
is
our
cast,
so
you
can
see
that
a
specific
request
goes
across
your
entire
system
and
you
can
see
how
much
time
it
is.
A
It
gets
expands
to
each
of
them
or
you
can
even
see
like
how
many
times
a
service
is
reached
during
to
fulfill
our
cast
like,
for
example,
during
one
of
my
debugging
session
with
traces.
A
I
and
I
realized
that
I
were
calling
like
the
authentication
service
for
four
times
five
times
for
every
cast,
because
I
was
all
the
time
like
requiring
to
check
the
authentication
token
token,
and
that
was
too
much
so
I
was
able
to
make
some
optimization
and
to
save
some
requests
and
make
my
my
you
know
response
way
faster.
A
In
this
case
I
was,
I
was
tracing
the
aws
request,
so
from
the
aws
client,
the
sdk
I
were
tracing,
I
was
tracing
all
the
requests
that
I
were.
I
was
doing
to
the
aws
this
visualization,
those
are
screenshot
that
comes
from
zipkin
zipkin
is
a
popular
tracer
written
in
java.
If
you
are
more
familiar
with
go,
you
can
use
jaeger
as
well.
There
are
links
about
those
stuff
at
the
end
of
the
slides
as
well,
so
the
obviously
it
doesn't
care.
I
don't
care
about,
like
the
language
that
you
write
to
it's
like
you.
A
Can
you
can
look
at
them
as
a
database,
so
jager
and
zipkin
are
like
a
database
that
you
can
push
all
your
metrics
in,
so
it
doesn't
matter
where
they
come
from
and
later
I
will
show
you
a
few
examples
with
javascript.
Obviously,
so,
when
I
think
about
like
code,
instrumentation
is
critical
for
you
for
your
application,
because
that's
how
a
developer
teaches
the
application,
the
language,
the
proper
language
that
you
will
look
at
when
trying
to
solve
an
issue,
and
usually
your
application,
has
logging,
metrics
and
tracing.
A
It
is
a
big
part
of
your
application.
It's
not
just
few
lines
of
code.
There
are
proper
libraries
and
in
some
way
you
have
to
organize
them.
So
in
the
idea
is
that
you
can
you
should
try
to
encapsulate
those
stuff
as
far
away
as
you
can
from
the
business
logic.
This
is
hard
for
logging,
but
for
tracing
a
metrics,
it's
a
bit
a
bit
is
a
little
bit
easier
and
you
can
use
like
event,
listener
and
stuff
like
that.
A
Another
important
part
is
the
propagation
because,
as
you
realized
like,
there
is
a
bag
of
information
that
has
to
go
from
a
service
to
another,
and
how
do
you
move
the
correlation
id
between
all
those
stuff?
It
depends
on
the
lang
on
the
protocol
that
you
are
using,
for
example,
in
http
or
tcp.
You
can
use
the
headers,
so
one
of
the
propagation
formats
is
called
b3
and
it
works
in
this
way.
So
this
is
a
tcp
or
an
http
request.
A
As
a
as
you
can
see,
the
headers
contains
a
bunch
of
x,
b3
stuff
and
those
are
information
from
the
trace
itself,
so
the
req,
the
the
service
that
they
make
their
cast
pass.
Those
headers
and
the
server
that
receive
their
cast
is
able
to
bundle
them
and
you
know
create
its
spam
that
has
the
same
trace
id
as
a
parent,
so
you
can
create
the
hierarchy
that
we
saw
before.
A
So
this
is
a
bit
of
an
overview
about
how
tracing
works
in
practice,
but
let's
see
how
open
telemetry
gis
works
so
hoping
telemetry
js
is
a
library
that
you
know
follow
the
open
tracing
experience.
The
open
telemetry
is
pretty
specification,
but-
and
it
is
everything
in
javascript,
so
you
can
check
it
out.
I
learned
a
lot
about
looking
just
looking
at
the
foldering,
so
I
decided
to
share
the
foldering
with
you,
because
I
think
it's
critical
to
figure
to
you
know
have
a
good
understanding
about
how
the
application
works.
A
So,
as
you
can
see,
there
is
a
folder.
It's
called
examples
and
there
are
examples
about
how
to
trace
like
http,
request,
https
request
or
dns
request
or
sql
requests
and
those
kind
of
stuff.
So
you
get
a
sample
application
that
helps
you
to
figure
out.
What's
going
on,
there
is
another
directory.
A
That's
called
packages
and
packages
gives
you
a
concrete
implementation
about
like
how
to
trace
specific
components
like,
for
example,
you
can
trace
grpc,
recast
or
http
request,
https
request
and
so
on
those
stuff
you
just
have
to
import
those
packages
and
your
up
your
application
will
be
traced
automatically.
A
So,
as
you
can
see,
there
are
like
prefix,
open,
telemetry
plugins
for
the
plugin
that
helps
you
to
instrument
your
application,
but
there
are
also
open,
telemetry
exporter
that
are
that
those
packages
contains
the
code
that
teaches
open
telemetry
where
to
push
your
metrics.
So,
as
you
can
see,
there
is
jaeger
and
zipkin
that
are
the
popular
tracer
that
I
told
you
about.
A
So
this
is
one
of
the
example
I
took
from
the
examples
directory
and,
as
you
can
see,
this
is
a
server
written
with
the
http
package
and
for
what
concerns
traces?
It's
easy.
A
It
is
just
easy
as
importing
like
a
single
file,
in
this
case
the
example
http
server
and
that
file
provision
and
provide
you
a
trace
configured
as
you
wish,
with
the
right
plugins
and
with
the
right
exporter.
So
let's
have
a
look
at
how
the
example
http
server
look
like
this.
Is
it
as
you
can
see
we
import?
We
recruit.
A
We
require
like
a
bunch
of
core
libraries
from
open,
telemetry,
the
api,
the
node
and
the
tracing,
and
you
also
have
to
decide
where
to
push
your
matrix
and
in
this
example,
based
on
an
environment
variable,
we
can
switch
between
jaeger
and
zip
team.
So
we
import
both
exporter
and,
as
you
can
see,
we
inject
into
the
tracer,
the
concrete
exporter.
A
So
here
you
can
see
that
there
are
no
plugins,
and
this
is
because
the
tracer
itself
comes
comes
from
comes
with
a
specific
set
of
plugins
already
provisional
by
default.
A
A
You
know
tracing
code
that
doesn't
go
into
the
business
logic
because
you
can
do
it
by
by
from
the
outside,
and
this
is
important
and
shimmer
is
the
library
that
is
used
by
open
telemetry
to
to
instrument
all
the
code
from
the
outside,
and
this
is
why
you
don't
you
don't
have
to
go
in
every
line
of
your
code
and
do
the
instrumentation,
as
you
will
may
do
in
other
languages
like
golang,
because
golden
doesn't
have
this
ability
java?
Has
it
because
you
can
instrument
the
jvm
but
not
for
for
javascript?
A
This
is
very
cool
and
yeah.
If
you
have
to
write
your
specific
instrumentation
for
your
business
code,
you
can
use
shimmer
as
well,
because
it's
it's
very
simple
and
you
don't
have
to
go
where
your
application
is.
A
So
this
is
it
I.
I
leave,
I
will
leave
you
a
bunch
of
links,
because
the
topic
is
very
big
and
I
hope
this
slides
and
presentation
will
help
you.
You
know
to
figure
out
that
this
is
a
topic
and
it's
not
too
hard
compared
with
other
languages
for
javascript
developer,
to
pick
it
up
with
tracing,
and
I
think
it's
super
important
when
you
do
when
you
have
a
distributed
system
or
also
with
a
monolith.
That
is
very
asynchronous.
A
So
I
use
it
a
lot
when
I
have
cues
or
when
I
do
even
sourcing,
because
I
can
tell
the
story
for
all
the
events
or
for
all
the
process,
and
I
can
follow
the
message
in
the
queues
and
I
can
tell
for
how
long
it
stays
and
which
worker,
processing
and
and
so
on.
So
the
first
link
is
my
github
into
my
twitter
account
because
you
can
reach
me
out
there.
My
dms
are
open.
The
second
one
is
the
open
telemetry.
A
When
you
can
learn
more
about
the
specification-
and
you
can
see
all
the
other
languages
supported
like
python,
golem,
php
and
so
on,
and
the
third
one
is
my
blog,
where
I
wrote
about
tracing
and
open
telemetry
as
well.
Jaeger
is
the
pop
one
of
the
popular
tracer
that
I
spoke
about,
so
you
can
use
it
in
open
source
and
it's
also
sponsored
by
them.
The
cncf,
so
honeycomb
is
a
company
that
provides
an
as
a
service
solution
for
for
observability
and
they
have
a
cool
blog
where
they
write
a
lot
about
this
stuff.
A
Those
topics
so
check
them
out
and
because
they
are
like
on
top
of
the
of
this
topic,
the
the
open
telemetry
has
a
guitar
community.
So
you
can
go
there
in
chat.
They
are
super
reliable.
I
learned
a
lot
from
them
and
you
can
also
contribute
because
it's
open
source
so
check
out
the
repository
itself
and
the
last
link
is
an
application
in
node.js
that
I
wrote
and
that
I
instrumented
with
opentelemetry.
A
It
is
a
a
sample
application,
so
it
contains
also
other
application
other
languages.
So
it's
an
e-commerce.
It's
an
e-commerce
like
it's
a
dummy
e-commerce
that
it's
in
it's
written
in
five
different
languages
and
it
is
instrumented
with
tracing
and
logs.
So
you
can
have
a
look
about
how
it
works
in
practice
over
there.
So
thank
you
for
your
time
and
let
me
know
if
you
have
any
questions.