►
From YouTube: Redefining cloud native debugging
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
Hey
everyone
and
welcome
to
my
webinar
about
redefining
cloud
native
debugging
or,
as
I
would
like
to
say,
never
wait
for
your
next
appointment
ever
again
before
we
begin.
Let's
do
a
quick
introduction,
so
my
name
is
noah
goldman.
I'm
a
product
manager
at
workout,
a
my
favorite
thing
in
the
world,
would
be
to
take
complex
technical
issues
and
make
a
super
simple
and
easy-to-use
product
out
of
them.
A
So,
let's
begin
so
before
we
speak
about
the
different
challenges
when
it
comes
to
cloud
native,
architectures
and
evolving
to
the
cloud,
let's
speak
about
why
cloud
is
so
much
fun.
So
cloud
is
a
major
thing
in
our
lives
and
there
are
a
lot
of
reasons
for
why
so
one
reason
can
be
that
cloud
is
flexible
and
scalable,
so
it's
easier
to
manage
higher
user
traffic.
If
you
have
them
or
maybe,
if
you
want
to
process
a
big
batch
of
data
cloud
native
architecture
makes
it
a
lot
more
easier
to
do.
A
Another
reason
for
why
cloud
is
so
much
fun.
Is
that
it's
reliable
right,
so
you
can
still
see
data
even
when
your
servers
are
down,
which
is
a
great
benefit.
A
It
has
great
disaster
recovery
plans,
which
is
another
advantage
when
it
comes
to
cloud
native
architecture
and
just
security-wise,
it
has
automatic
mandatory
update,
which
is
great,
and
it
has
data
security
monitoring
and
for
all
those
reasons.
This
is
why
cloud
native
is
so
much
fun
and
we
love
to
use
it
before
we
deep
dive
into
the
different
challenges.
Let's
see
some
numbers
and
some
graphs,
because
graphs
are
fun.
A
So
if
we
thought
that
cloud
native
is
a
huge
deal,
it's
going
to
be
a
much
bigger
thing
in
the
future
and
it
will
take
an
even
greater
part
in
our
lives
in
the
next
four
years.
So
by
2024
production
grade
cloud
native
applications
will
expand
to
70
from
10
of
all
apps
in
2020,
which
is
a
major
thing.
Cloud
is
going
to
be
a
bigger
deal
in
the
future,
and
this
is
why
we
want
to
learn
how
to
all
those
challenges
will
affect
us,
and
we
want
to
learn
about
those
challenges.
A
So,
let's
speak
about
the
different
challenges
that
cloud
native
architecture
brings
to
us.
So
one
challenge
can
be
just
compliance
requirements
right,
so
you
have
to
make
sure
that
your
application
is
compliant
and
ready
to
be
run
in
the
cloud
which
is
not
always
that
easy.
I
can
take
time.
Another
challenge
can
be
designed
modifications.
A
Sometimes
you
will
have
to
redesign
your
app
and
the
different
architectures
to
better
fit
the
cloud
native
architecture.
A
Another
challenge
is
that
downtime
can
occur
here
and
there
when
evolving
to
the
cloud-
and
you
know
just
lack
of
expertise-
you
we're
not
always
familiar
with
everything
and
we
will
have
to
learn
how
to
use
the
new
tool
and
expense
our
toolkit
and
let's
face
it.
It
takes
time,
and
it's
not
that
easy.
A
So
all
of
those
challenges
are
super
important.
We
definitely
need
to
learn
how
to
overcome
those,
but
I'm
here
to
speak
about
one
challenge
that
is
especially
close
to
my
heart
and
it
can
affect
all
of
us.
So
the
challenge
is
the
challenge
of
debugging
your
cloud
native
applications,
and
this
is
why
we're
here.
So,
let's
speak
about
this
challenge
before
we
speak
about
the
actual
challenge,
I
want
to
speak
with
you
about
the
traditional
debugging
methods,
all
the
different
debugging
tools
that
we
are
all
familiar
with
and
love.
A
I'm
sure
all
of
us
have
used
at
least
one
of
those
methods.
So
let's
deep
dive
into
each
and
every
one
of
those
and
see
that
they
might
be
great
but
they're,
not
that
much
of
a
good
fit
when
it
comes
to
debugging
our
cloud
native
architecture
applications.
A
So
the
first
one
will
be
command
line,
debugging,
which
is
great,
but
it
has
a
few
disadvantage.
So
the
first
is
eventually
to
be
that
it
has
limited
amount
of
commands.
So
it's
not
like
you
have
this
great
gui
with
different
buttons.
You
basically
have
a
few
commands
that
you
can
use.
The
output
is
not
always
clear
there.
If
you
remember
it's
a
black
screen,
you
see
a
big
batch
of
data
there.
It's
not
always
that
clear
and
easy
to
read
it's
complicated
to
use
again
and
almost
always
it
will
require
more
investigation.
A
So
it's
not
that
you
will
just
get
the
data
you
need
and
solve
your
bug.
You
almost
always
have
to
do
some
more
investigation
and
try
to
solve
the
bug
in
different
ways.
So
again
come
online
debugging
great
tool,
but
it's
not
that
great
all
right,
so
another
tool
that
we
all
know
and
familiar
with
is
local
debugging,
which
is
also
great,
but
it
has
a
lot
of
disadvantages
as
well.
So,
first
of
all
one
of
the
drawbacks.
A
What
we're
talking
about
local
debugging
is
production
configurations
now,
when
I'm
speaking
about
production
configurations,
I'm
speaking
about
reproducing
your
production
environment
in
your
local
machine
right,
so
it
can
be
your
runtime
environment.
Maybe
you
need
to
reproduce
the
production,
operation
systems
or
maybe
different
versions
of
the
operation
systems.
You
need
to
reproduce
your
source
code
versions
right.
You
have
a
certain
source
code
version
in
your
production
that
you
have
to
make
sure
you
run
in
your
local
machine,
your
production
dependencies.
A
You
have
to
reproduce
them
locally
in
order
to
find
the
specific
bug
or
just
network
configurations
or
any
other
conditions
that
you
have
in
your
production.
It's
not
always
the
easiest,
the
easiest
thing
to
reproduce
them
on
your
local
machine
when
you're
troubleshooting,
a
certain
bug.
Another
drawbacks
when
we're
speaking
about
local
debugging
is
the
application
state
right.
The
application
state
can
be
the
actual
data.
A
Sometimes
it's
not
the
easiest
thing
to
reproduce
your
production
data
in
your
local
machine
right
that
is
sensitive,
it's
not
always
possible
to
reproduce
it
or
you
know
what
just
the
actual
production
bugs
you
have
to
copycat
your
users
and
try
to
execute
exactly
the
same
flow
that
they
did
in
order
to
reproduce
the
bug
locally
and
reproduce
what
happened
in
production
locally?
And
it's
not
always
easy.
You
know
what
sometimes
it's
just
impossible,
and
those
are
just
a
few
of
the
reasons
for
why.
A
Another
tool
can
be
logging
and
tracing,
which
is
still
great
too,
but
it
has
a
few
disadvantages
as
well.
It's
time
consuming,
you
have
to
follow
those
logs,
make
sure
you
understand
them.
Can
you
even
predict
your
bugs
right?
Most
of
the
time
we
cannot
predict
the
bugs,
which
means
we
don't
always
have
the
right
log
lines.
A
Do
you
even
really
log
every
line
of
code
that
you
write?
I
know
I
don't
most
of
the
line
of
code
that
we
write.
We
don't
have
log
lines
from
the
for
them
and
in
the
money
time
we
might
have
a
few
blog
lines
this
week
in
terms
of
performance
and
storage
costs.
A
It
can
cost
a
lot
of
money
and
you
really
have
to
keep
maintaining
those
logs.
You
have
to
add
more
logs
or
remove
more
logs
and
it's
just
constant
maintenance
and
this
for
all
those
reasons.
This
is
why
login
interesting
it's
not
such
a
great
tool
when
it
comes
to
debugging
your
cloud
native
applications.
A
Another
great
tool
can
be
remote,
debugging
a
great
again
great,
great
great
tool,
but
it
stops
the
app.
So
you
don't
always
want
to
stop
your
application
where
you'll
be
bugging
it,
you
need
to
know
your
service
intimately
and
it's
almost
impossible
in
the
cloud.
You
have
many
servers
and
it's
not
that
easy
to
connect
to
them
and
to
understand
which
server
you
want
to
debug
and
in
terms
of
security.
A
A
Another
thing
that
I
want
to
speak
with
you
about
is
differential
production
blending.
A
Well,
if
you're
doing
that
good
for
you,
let
me
know
how
it
went
for
you
crossing
fingers
and
hope
for
the
best,
but
I
have
nothing
to
say
to
you.
So
good
luck
with
that.
A
So
we
spoke
about
all
the
traditional
debugging
ways
that
we
all
know
today.
But
let's
speak
about
the
actual
challenges
that
comes
with
debugging
your
cloud
native
architectures.
There
are
different
challenges,
so
the
first
one
would
be
that
you
give
it
up
the
control.
You
don't
have
the
control
anymore,
and
this
is
not
always
easy
to
deal
with.
A
Another
challenge
is
that
it
has
high
complexity,
complexity,
architecture,
so
when
I'm
speaking
about
high
complexity
architecture,
I'm
talking
about
multiple
micro
services,
communicating
with
each
other
it's
hard
to
get
a
holistic
view
of
the
app
when
you're
dealing
with
such
microservices
and
just
recreating
the
application
state.
It's
not
that
easy
when
your
architecture
is
so
complex.
A
Another
drawback
is
the
dynamic
environment
changes.
So
it's
a
huge
challenge.
You
have
instances
that
are
deployed
and
turned
down
dynamically,
and
it's
not
always
that
easy
to
deal
with
there's
no
up
or
process
we
can
actually
attach
to
in
traditional
debugging,
which
make
things
a
lot
harder,
and
you
know
what
just
access.
A
Sometimes
you
don't
have
the
right
access
that
you
need
when
it
comes
to
debugging
your
cloud
native
architectures
and
those
are
just
a
few
of
the
challenges
that
are
brought
to
us
when
we
try
to
debug
our
cloud
making
applications
before
we
deep
dive
into
the
different
solutions.
I
want
you
to
all
think
about
this
story,
so
you're
developing
your
application.
Everything
is
great,
you
add
in
new
features,
everything
is
going
smooth,
you
all
have
fun.
The
team
is
enjoying
their
lives
and
everything
is
awesome.
A
The
team
shifts
from
being
nice
and
in
joyful
mood
to
panic,
attack
and
being
all
stressed
out.
I'm
sure
it
all
happened
to
all
of
us
at
least
once
when
we're
speaking
about
our
development
careers.
A
Think
about
how
much
you
wanted
to
just
solve
the
bug
as
quickly
as
possible
and
get
it
over
with
this
is
why
we're
here
we
want
to
learn
about
how
we
can
do
that
to
avoid
such
panic
attacks
and
how
we
can
solve
our
clients
and
avoid
such
situations
when
we
all
in
panic-
and
we
just
want
to
finish
with
the
bugs.
A
So
I
want
you
to
think
about
this
story
and,
let's
dive
into
the
different
solutions
that
we
have
so
one
solution
I
want
to
suggest
is
apm
tools.
Apm
tools
are
application.
Performance
management,
management
or
monitoring
tools
depends
on
how
you
want
to
use
it,
so
they
collect
metrics
data
and
they
tell
you
what's
going
on
within
your
application.
A
Metric
data
can
be
anything
including
transactions,
analytics,
availability,
log
scraping,
which
are
all
presented
in
a
beautiful
dashboard.
Those
tools
can
be,
you
might
know
them
as
a
new
relic
dynamic,
dyna
trace,
and
there
are
many
more,
but
they
have
a
few
drawbacks
as
well,
so
low
fidelity
data
is
one
of
them.
The
data
is
collected
at
low
fidelity.
So
while
the
solution
can
be
relied
on
to
alert
you
when
something
is
wrong,
they
provide
little
direction
as
to
just
what
that
something
is
and
how
we
can
fix
it.
A
So
again,
it's
this
is
just
one
drawback.
It
has
significant
learning
curve,
we're
not
always
familiar
with
this,
and
it
takes
time
to
learn
it
multiple
tools
to
monitor
various
aspects
of
the
application.
So
again,
it's
not
just
one
tool
that
you
have
to
implement
and
adapt
to.
You
have
to
install
multiple
tools
and
learn
how
to
deal
with
them,
which
again
it's
a
major
drawback
and
it
just
consumes
more
resources
and
it
drives
up
your
cost.
So
apns
are
great
too.
A
You
might
want
to
use
them
when
it
comes
to
debugging
your
cloud
native
architecture
applications,
but
they
do
have
a
few
drawbacks
that
you
might
want
to
take
into
consideration
when
debugging
your
applications.
A
Another
solution,
I
would
like
to
bring
is
exception
catching
exception.
Gettings
are
tools
that
automatically
capture
and
track
exception
as
they
occur.
They
will
help
you
identify
patterns
or
repetitive
behaviors
within
your
applications
such
tools,
you
might
know
them
as
sentry
or
bug
stocks,
and
there
are
many
more.
They
have
a
few
disadvantages
as
well.
So,
first
of
all
again
much
like
atm
tools.
A
Those
are
another
tool
that
you
have
to
use
bugs
also
do
not
always
come
from
exceptions
right
most
of
the
bugs
that
we
have
are
actually
being
created,
because
the
developer
did
something
wrong,
or
maybe
the
business
side
didn't
think
about
everything
through.
So
most
of
the
bugs
are
not
always
coming
from
exceptions
exception.
Catching
two
can
act
differently
in
various
environments,
so
this
is
one
thing
that
we
definitely
want
to
take
into
consideration
when
we
use
it
to
debug
our
application
and
again
much
like
different
solutions.
A
Not
all
the
data
is
available,
so
it
almost
always
requires
some
deeper
investigations.
When
we're
trying
to
debug
notifications
so
again
exception.
Catchings
are
helpful.
They
will
be
great,
but
then
will
not
solve
everything
you
need
to
solve.
A
The
final
solution
I
would
like
to
bring
up
will
be
live
debuggers,
so
lively
buggers
are
production,
great
real
time.
Debugging
they
collect
data
on
different
snapshots
of
your
application.
They
can
do
that
on
demand
from
any
environment
without
actually
having
to
stop
your
application.
You
can
do
that
with
just
one
click.
You
can
set
non-breaking
breakpoints,
which
are
the
coolest
thing
in
the
world
and
get
data
on
the
fly
without
actually
stopping
your
all
either.
A
It
has
great
advantage.
First
of
all,
you
don't
have
to
create
and
reproduce
your
local
state,
your
production
state.
Luckily,
because
you're
basically
debugging
your
production
application,
the
code
that
you
will
debug
behaves
exactly
as
it
is
in
production
because
again,
you're,
debugging,
the
actual
production
environment,
you're,
not
debugging
locally,
reproducing
bugs
again,
it's
a
lot
easier
because
you
don't
have
to
follow
your
users
step
by
step
and
why
they
need
to
reproduce
the
bug.
A
You
can
just
have
it
right
right
there
in
your
production
environment,
it
has
no
performance
impact
at
all
and
it
has
non-breaking
breakfast,
which
is
the
coolest
thing
in
the
world.
You
just
place
a
breakpoint,
as
you
know
it
in
your
ide,
but
the
difference
is
that
it
just
doesn't
stop
your
application.
A
So
for
all
those
reasons,
this
is
why
I
recommend
live
debuggers
when
it
comes
to
debugging
your
cloud
native
architecture
applications
yeah.
So
this
is
my
final
solution
and
I
want
you
to
go
ahead
and
think
back
about
the
story
that
we
just
mentioned
a
few
minutes
ago
and
think
about
how
cool
it
will
be.
A
If
you
have
such
solutions
and
you
will
be
able
to
solve
your
cloud
native
applications,
bug
a
lot
faster
with
not
having
to
deal
with
such
panic
attack,
you
will
be
able
to
solve
the
bug
and
move
on
with
your
life
and
enjoy
your
friday
night
plans
so
yeah.
Those
are
all
the
different
solutions
that
I
can
offer
you
when
it
comes
to
debugging
your
cloud
native
applications.