►
From YouTube: From Streaming to Studio--The Evolution of Node.js at Netflix - Guilherme Hermeto, Netflix
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
A
A
A
A
A
The
Rope
handler
file
may
return
an
array
of
functions
and
you
can
also
specify
middlewares
or
not
cork
dot.
Jason
the
platform
will
be
responsible
for
three
main
areas:
observability
with
metrics,
distributed
tracing,
help,
dashboard
and
centralized
logging,
the
boug
ability,
with
exception
management
and
diagnostic
tools.
A
A
At
the
core
of
the
platform.
We
have
a
restful
application
with
its
in
ground
module,
put
rest
file
and
in
route
module
are
open
source
check
them
out.
On
github,
the
enroute
module
is
responsible
to
read
the
mudguard
JSON
file
from
the
customer
application
and
use
it
to
locate
all
the
route
handlers.
A
When
we
release
a
platform
version,
we're
actually
publishing
a
docker
image
with
a
node
called
platform
runtime,
and
when
a
customer
publishes
a
new
version
of
the
services
we
layer,
those
images
copying
their
application
code
into
the
platform
image.
We
as
a
platform,
are
responsible
for
monitoring
a
mitigating
issues
with
the
running
process.
When
the
application
image
is
deployed,
the
service
is
ready
to
receive
production
traffic.
A
A
We
have
to
authenticate
employees
partners
and
then
decide
the
level
of
access
that
each
individual
user
has,
and
even
though,
both
of
those
types
of
services
requiring
this,
the
tracing
in
centralized
logging
simply
and
retention
are
not
the
same,
for
example,
on
streaming
applications
with
simple
0.1
percent
of
requests,
while
on
content
production
applications,
it
makes
sense
to
sample
100%
and
why
we,
it's
only
cost
effective
to
keep
streaming
logs
readily
available
for
the
last
24
hours.
We
probably
won't
increase
the
law
presentation
for
the
other
applications
to
let's
say
a
week.
A
These
applications
they
are
different,
but
they
also
share
a
lot
of
concerns
around
observability,
which
metrics
really
matter
the
book
ability.
How
do
I
quickly
find
out
what's
wrong
with
my
service
in
configuration,
how
do
I
configure
the
best
configuration
for
running
a
service
in
production?
That's
important
too.
A
Unfortunately,
the
original
architecture
had
its
limitations.
The
original
design
made
a
lot
of
assumptions
about
infrastructure
and
code
paths.
Other
use
cases
were
just
not
top
of
mind
at
that
point,
and
stability
was
a
major
concern.
Let
me
expand
on
that,
so
our
team
tries
really
hard
not
to
break
netflix
on
new
platform
releases.
It's
a
slow
process.
A
Every
platform
releases
requires
that
we
can
narrate
the
changes
into
multiple
services,
take
1%
of
the
traffic
and
comparing
it
with
a
baseline.
If
there
are
any
issues
or
performance
degradation,
we
search
for
the
root
cause,
we
fix
it.
Then
we
rinse
and
repeat
until
we
get
performance
that
as
the
this
model
just
won't
fit
well
for
the
fast
pace
in
new
applications
that
we
only
support.
It
creates
risk
on
one
side
and
reduces
velocity
on
the
other.
A
And
one
added
piece
of
complexity.
So
when
we
took
a
step
back
and
look
at
the
whole
customer
base,
we
saw
that
we
have
more
difference
than
just
content,
production
and
streaming
applications.
Some
of
those
applications
would
like
a
fork
or
someone
rest
and
most
of
the
new
world
graph
QL
when
I
analyze
all
the
puzzle,
pieces
I
got
the
conclusion
that
the
best
approach
moving
forward
was
to
extract
all
those
components
from
the
platform
into
self-contained
modules
or
plugins.
Yeah
I
went
there
plugins
and
what
plugins
solve
a
problem?
A
Well,
plugins
allow
us
to
remove
the
fast-evolving
pieces
of
the
platform
source
code,
creating
much
needed
stability
for
the
string
applications
and
most
of
them
can
be
reusing
all
or
almost
all,
applications
with
maximize
called
reusability
and
minimize
the
support
burden,
so
we're
going
even
further
further
than
that,
we
are
making
everything
plugins
like
everything
well,
except
that
tiny
little
piece
of
platform
code
that
load
plugins.
Everything
else
is
a
plugin,
even
the
sir,
and
that
gives
us
a
lot
of
flexibility
right
now
or
code
is
very
intertwined
with
rest
file.
A
When
we
were
designing
the
plugins,
we
research
a
lot
of
other
plugins.
We
search
different
plugins
implementations,
including
how
happy
and
fast
I
implement
plugins,
and
we
decided
that
we
need
a
little
bit
more
structure
so
well
happy
and
fast
fight,
plugins.
You
pass
application
server
back
to
the
plugin
and
let
the
plugin
would
fight
a
server.
We
chose
a
format
where
the
plug-in
actually
provides
hooks
and
the
platform
control.
How
and
when
those
hooks
are
called
for
comparison.
This
is
the
pacify
plugin.
A
A
A
Then
the
bug
interface
is
used
by
the
platform
debug
server,
which
runs
in
parallel
the
custom
service
and
provide
real-time
health
information.
For
that
instance,
the
mock
interface
allows
our
customers
to
mock
a
plugin
during
unit
or
integration
tests
in
Leslie.
The
routes
Keys
allow
us
to
register
platform.
The
final
routes,
for
instance
a
graph
QL
or
a
koala
plug-in
put
the
final
slash
rough
crowd,
saving
the
user.
The
trouble.
A
This
pluggable
architecture
enabled
us
to
create
another
abstraction
which
we
call
application
profiles.
Application
profiles
are
type
of
applications
with
similar
characteristics,
meaning
they
use
the
same
plugins.
So
an
application
profile
can
be
seen
as
a
list
of
plugins
to
load
for
a
given
application.
We
actually
design
it
as
a
module
that
imports
the
plugins
and
export
in
an
array
of
loaded,
plugins.
A
So,
since
profiles
only
load
specific
plugins,
it
reduces
the
risk
of
a
plug-in
built
for
content
production
to
break
an
application
on
the
streaming
pad,
for
example,
if
I
just
load
the
security
for
content,
production
and
I
change
that
plug-in
very
after
as
the
profiles
for
streaming
applications,
don't
load
that
particular
plug-in.
It's
fine
that
that
plugin
evolves
fast
and
not
even
limited
plugins.
A
A
What
we
go
from
here
well
for
us,
the
next
step
is
to
allow
our
pioneers
teams
to
create
application
profiles
and
give
to
their
customers,
enabling
them
to
virtually
build
platforms.
On
top
of
a
platform,
the
interface
that
I
show
you
it's
private
to
our
team
at
this
moment,
but
we
plan
to
release
that
to
our
partner
teams
in
the
coming
months.
A
Right
now,
we're
trying
to
test
validate
it
and
solidify
it
before
we
make
it
a
public
interface
to
them,
and
it's
all
very
open-ended
but
very
excited,
so
we're
very
excited
to
see
where
this
is
going
and
even
beyond
BFFs.
We
are
now
looking
into
serving
federated
graphs
and
server-side
render
applications
so
possibilities,
possibilities,
possibilities.
A
Tracing
zip
King
is
definitely
the
way
to
go
for
Diagnostics,
there's
flame
scope,
which
you
use
Linux
birth,
so
you
can
use
the
Linux
perf
package
available
on
NPM.
We
use
the
same
package,
unload,
quark
and
Leslie
for
exception.
Management
center
is
very
well
known
and
easy
to
use
and
I
also
always
liked
air
brake.