►
From YouTube: Node.js Diagnostics WG Meeting - 2018-04-18
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).
B
A
A
A
Okay,
so
going
through
this
the
deep
dive
topics.
Again,
it's
like
people
have
specifics
for
topics
they
want
to
discuss
in
a
deep
dive
thing
please
out
in
there
and
we've
got
one
for
the
async
context.
Stuff
talk
a
little
bit
about
that.
It's
unscheduled
but
I
think
some
of
the
stuff
around
it
is
coming
together
and
so
talk
about
that
when
we
get
to
it
in
the
agenda.
A
C
D
E
D
F
C
A
A
D
A
B
A
A
The
so
hasten
cooks,
tracking
issue,
I
know
that
somebody
from
was
at
New
Relic
chimed
in
on
this
saying
that
they
are
seeing
things
fairly,
stable.
I
think
that
the
last
question
here
was,
you
know
the
the
impact
of
promised
hooks
and
I.
Think
yang
had
some
action
to
investigate
that
at
some
level
at
least
some
kind
of
write
up
and
I
think
any
progress
was
made
there
I
don't
know
if
anyone
else
has
any
update.
Sally
yeah.
D
No,
that's
what
he
summarized
is
correct,
so
so
the
next
action
was
for
yang.
To
summarize,
like
I,
write
a
lot
with
the
proposal
on
what
might
be
in
the
mid
for
Miss
works.
The
main
thing
blocking
async
hooks
at
this
point
is
the
question
about
performance
and
whether
or
not
we
need
some
changes
in
the
API
in
order
to
be
able
to
address
performance.
That's
why
it's
a
little
bit
so
and
we
haven't
seen
that
dot
from
yang
just
yet,
and
hopefully
can
we
bring
him
get
him
to
talk
about
that.
D
The
other
question
is
recently
at
the
TSC
meeting.
Bradley
brought
up
the
topic
of
zones
that
that
zones
should
be
pursued
again
at
the
TSE
and
whether
or
not
so
previously
TS
he
was.
It
was
claimed
that
node
was
blocking
it.
Although
there's
no
official
record
of
that
and
I
think
even
Matteo
rudabeh
Jones
proposal,
so
I.
B
Can't
I
can't
fill
briefly
like
we
have
thought
a
little
bit
on
what
could
as
don't
think
for
for
now.
Look
like
those
brought
more
questions
than
than
answers.
I
would
have
to
say
especially
related
to
how
zones
are
supposed
to
work
and
the
main
difference
between
those
and
nursing
context.
Tracking
mechanism,
such
as
icing
cooks,
especially
in
terms
of
performance.
B
B
D
B
My
main
my
main
concern:
it
is
not
haunted
on
the
JavaScript
side,
but
on
the
fact
that
on
outside
I,
don't
see
how
we
could
implement
them,
not
on
top
of
us
in
cooks,
I
think
we'll
have
to
so
it's
asking
hooks.
We
measure
this
as
an
impact
of
maybe
some
8%
or
something
like
that.
On
top
of
our
platform,
something
like
it,
I
am
not
comfortable
in
taking
that
hit
all
the
time.
B
We
had
some
HTTP
benchmarks,
it's
more
or
less
what
it's
coming
out,
but
we
have.
We
have.
The
raw
data
is
being
finalized,
so
we
have.
We
have
done
a
lot
of
work
between
these
and
monkey
patching
to
actually
check.
What's
what's
the
status
of
things
it
has
been
delayed
for
some
internal
stuff
and
therefore
so
once
that
should
be
on
its
way
it
out
of
it
has
been
unlocked.
B
B
So,
which
is
not
what
Singh
cooks
is
a
lower-level
mechanism
for
that
and
I
I
strongly
believe
that
we
need
one
okay,
that
beings
owns
is
completely
or
whatever
we
want
to
call.
It
is
completely
up
in
the
air.
I
cannot
I,
not
so
mine.
Only
my
interest
in
this
is
because
I've
seen
too
many
times
as
that
concept,
badly
implemented
badly
supported
and
genetically
badly
used
in
the
ecosystem.
To
convince
me
that
the
platform
needs
to
provide
it.
G
So
tonight
this
is
Marc
by
the
way.
I'm,
you
know
hijacking
Mike's
Mike
we
have.
Has
anybody
ever
articulated?
What
properties
this
pace
zones
continuations?
Something
should
support
like
I've,
seen
several
proposals,
but
it's
not
clear
like
what
are
the
fundamental
properties
that
this
is.
Let
me
let.
B
Me
share
what
so,
basically
James
and
myself
need
the
Brutes
attack,
basically
doing
the
bare
minimum
for
contracting
a
synchronous
context
leaving
out
the
contention
pistols
like
ever
handling,
for
example,
yeah
sure
that
that
would
be
awesome.
I'll
put
the
link
here.
It's
it's
not
it's
not!
That
is
anything
in
secret.
These.
D
A
That's
fine,
okay
is
there,
is
there
an
issue
up
in
or
something
or
did
this
just
come
up
in
conversation,
TMC
or
conversation
on
the
TSC?
Okay
and
did
it
come
up,
is
sort
of
a
thing
of
like
this
is
what
I
know
would
like
to
do
or
like
hey?
We
should
go
back
to
the
because
I
thought
the
zone
stuff
was
a
necklace,
crypt
proposal.
Yeah.
A
Take
on
that
was
so
my
take.
That
was
that
there
were
some.
You
know,
concerns
with
the
air
handling.
Api
is
and
the
air
handling
semantics
that
were
proposed
with
the
zones
proposal
and
that
the
conversation
just
kind
of
got
into
a
quagmire
and
people
were
talking
past
each
other
right,
and
it
just
got
to
like
this
really
deep
level
of
like
what
about.
When
I
have
this
code.
A
A
No
I
agree,
I
think
that
from
so
here's
here's
here's
my
take
and
I
think
this
might
go
into
some
of
the
next.
The
the
next
agenda
items
when
we
get
there
is
that
what
what
we
need
is
we
need
sort
of
clear
semantics
about
async
execution
flow
and
then
you
can
throw
an
API
on
top
of
that
right
and
that
API
could
look
very
much
like
zones,
but
it
would
leverage
the
same
sort
of
set
of
concepts.
B
Tend
to
I
tend
to
agree,
I
tend
to
agree
this
two
things
can
can
more
or
less.
This
is
very
important,
though,
like
I
think
it's
providing
this
information
as
a
top-level,
the
semantics
and
the
API
as
a
top-level
API
ignored
at
least,
but
if
JavaScript
as
well.
It's
something
that
is
hard
to
create
the
consensus
needed
to
do
this.
Yeah
I,
agree
and
I
almost
feel
like.
If
you
can
get.
A
To
a
on,
like
a
set
of
you,
know
clear
well
under
the
concepts
right,
then
what
you
can
start
doing
is
you
can
start
layering
on
top
of
those
well
understood
concepts
on
a
you
know,
different
implementations
of
api's
for
things
like
asynchronous
air
handling,
or
you
know
a
spend
the
context.
You
know
continuation,
storage
or
things
like
that.
That
zones
is
actually
proposing
to
solve
right
and
then
I
think
what
you
could
then
do
is
you
can
have
a
with
the
right
set
of
concepts
and
terminology,
and
you
know
shared
understanding
of
that
stuff.
A
B
A
B
B
B
B
Okay,
so
that
it's
it's
not
always
enabled
you
create
one,
and
you
create
a
bunch
of
contexts
that
you
want
to
track
that,
if
you
don't
want
that,
you
fold
it
and
nothing,
you
have
no
covert
motorized,
okay
and
that's
the
first
that
that's
one
of
the
first
thing
and
the
second
thing,
the
missing
error,
handling.
Okay,
also,
it
helps
not
having
a
root
zone,
helps
a
lot
on
some
side
edge
cases
on
module
loadings
so
that
you
can
given
that
there's
no
root
zone,
you
need
to
create
it
from
a
user
interaction.
B
A
B
B
D
D
You
think
hooks
listens
to
way
too
many
events
and
I
think
or
that's
part
of
the
problem.
So
if,
if
here,
if
we
could
ensure
that
the
events
are
triggered
at
the
API
level,
so
you
will
need
to
emit
events
for
all
the
lower
levels
of
the
API
already
there
is
propagating
context
forward,
but
in
certain
cases
it's
not
necessary
for
us
to
have
context
if
we
can
resurrect
it
at
a
higher
level.
Well,.
A
There
is,
you
know,
there's
one
point
in
time
when
you
call
from
from
a
user's
point
of
view
right
like
like
you
call,
set
timeout
right
and
you
pass
a
function
in
to
set
timeout
right
and
that's
the
point
that
we
actually
care
about.
Saying
like
hey.
We've
got
something
interesting
that
we
need
to
use,
or
you
know
to
track
this
asynchronous
context.
Is
we
took
a
function?
A
We
passed
it
across
a
boundary
such
that
that
function
is
going
to
be
invoked
later
in
some
other
new
contacts,
new
async
context
right
and
those
are
the
interesting
things
right
and
all
of
the
other
stuff
ends
up
being
very
noisy
from
the
point
of
view
of
somebody
who
just
wants
to
understand
nascent
context
right.
Is
that
a
fair
paraphrase
of
what
you
said?
Really?
Yes,.
D
A
So
I
I
think
you
know
some
of
the
stuff
like
weave
some
of
the
stuff
that
we've
been
talking
about
with
trying
to
get
a.
You
know
some
some
more
some
more
clear
definitions
around
async
context,
sort
of
addresses
some
of
this
stuff
right
and
it
introduces
some
concepts
that
I
think
we
can
reason
about
and
I
think
it
would.
You
know
you
could
I
haven't
looked
at
how
to
do
this
in
node
and
I.
Don't
know
all
of
the
places
where
we'd
have
to
go
in
and
tweak
coding,
node,
but
right.
G
B
B
Are
actually
this
is
actually
part
of
this
reported
API
is
actually
fine,
they
will
be
to
be
instrumented
as
well,
but
that's
their
job.
The
major
the
major
problem
is
modules
that
use
internal
functions
and
internal
stuff.
That's
why
asking
cooks
that
implemented
the
way
they
are,
because
we
can't
really
trust
our
users.
G
No
I
was
sort
of
at
a
very
high
conceptual
level,
like
my
intern
use
that
approach
and
you're
absolutely
right.
You
have
to
go
in
and
do
it
for
the
internal
api's
too,
but
conceptually
you
like,
and
if
I'm
a
good
user
when
I
call
across
that
boundary
from
my
code
into
the
node
core
code
and
okay.
So
for
the
bad
users,
that
boundary
might
be
things
that
were
internal
and
those
need
to
be
caught
as
well.
But
that
first
transition
is
what
you
care
about.
Yeah.
B
B
You
will
need
to
get
that
reference
that
that's
at
that
point
of
that
context
will
need
to
be
surfaced,
surfaced
some
that
it
goes
into
our
handling
like
it
is
the
problem
of
contracts
tracking.
It
goes
into
it's
tied
somehow
into
Harrow
handling.
So
it's
very
hard
not
to
do
that
without
not
talking
about
IRA
handling
Dominic,
then
he
called
I
said
plenty
in
a
very
long
issue
in
discussion.
We
entered
the
full
something
stopped
so
so.
B
If
it's
an
internal
thing,
so
if
you
have
some
JavaScript,
that
is
only
run
internally
mm-hmm,
let
me
say:
I
have
two
streams:
okay,
now
they
use
it.
I
I
pipe
two
strings
together:
okay,
so
I
have
data
coming
from
cipa
from
C
going
to
a
stream
in
JavaScript,
then
going
back
into
into
into
thing
to
see
this
out.
The
piping
thing
works
by
the
way.
I
know
if
you're
familiar
with
of
this
stuff.
B
So
it
goes,
it
goes
up
and
down-
and
you
go
you
do
this
now,
as
a
user,
I
might
be
only
interested
when
that
stuff
ends.
Okay,
typically,
I
want
to
track.
If
that,
if
my
strings
pipeline
ends
so
in
theory,
I
will
only
need
to
be
to
have
the
context
on
my
latest
call
back:
okay,
okay,
however,
those
values
entities
can
emit
an
error
event
at
any
point
in
time.
A
B
It
is
the
problem
if
you
bind
it
to
close
your
scope,
so
you
either
you
put
it
in
projects
cope
either.
You
put
you
don't
put
into
closure
scope.
Okay,
if
you
do,
if
you
put
into
closure
scope,
it
won't
work
yeah,
okay,
because
the
event
emitter
model
presumably
allows
you
to
use
top
level
functions.
That's.
G
G
I
think
one
of
the
challenges
is:
there's
a
sort
of
a
general
default
semantics
which
you'd
like
to
have
people
happen
automatically.
But
there
are
weird
things
like
people
plumbing
into
the
internals:
not
perfect
alignment
between
you
know,
lexical
scoping
and
the
code
and
the
dynamic
scoping
that
you
want
and
where
things
are
linked
and
where
their
cause
and
user
space
queuing.
That
mean
you
need
to
have
sort
of
a
nice
default,
behavior,
plus
a
clean
way
to
override
that
explicitly.
B
A
It's
it's
it's
it's
interesting
to
discuss
it
I
just
think,
like
so
I
think
the
the
summary,
though,
is
that
there
you
know
zones
is
resurfaced
in
discussion,
primarily
because
the
concerns
around
performance
impact
of
async
hooks
and
the
thinking
that
zones
can
be
implemented
more
better
at
the
VM
level.
I.
B
Would
not
do
that
I
would
not
say
I
would
I
would
say
that
the
discussion
has
been
wrestle
phase
because
of
all
of
what
you
said,
plus
the
fact
that
I
I,
myself,
James,
probably
Ally
and
I,
don't
know
who
else
believed
that
there
is
a
need
for
a
uniform
way
to
track
their
synchronous
context
across
JavaScript
applications?
Okay,
yeah,
it
is
kind
of
a
statement,
sake,
agreeing
that
we
are
saying
that
loud
and
agreeing
that
this
is
a
need.
Then
we
can
discuss
what
that
might
mean.
What
that
might
look
like.
B
A
Okay,
anything
else
on
this
stuff,
so
one
question
I
have
is
for
async
hooks
I
mean.
Is
it
been
and
I
think
the
question
was?
Is
it
going
to
get
out
of
experimental
for
no
ten
I
haven't
heard
anything
explicit
by
my
you
know.
My
take
on
the
discussion
were
happening.
Having
now
is
that
the
answer
is
no.
Is
that
fair,
Sonique
annular
space,
what
I
thought
the
the
goal
was
to
have
a
sink
hooks,
be
out
of
experimental
for
no
ten.
B
For
no
tennis-
yes,
yes,
I
would
say
so
how.
But
it
sounds
like
we're
far
away
from
that.
I
am
NOT,
mrs.
su
coche,
even
that
the
the
data
that
I
scene
compared
to
a
monkey-patching
approach
for
APM
I,
would
say.
I
would
lead
to
right.
We
need
to
get
the
output
data,
but
I
would
say
the
approach
with
a
Singh
cooks
completely.
How
performs
in
all
possible
cases,
even
with
promises
out,
performs
yeah
iswe
better
in
any
in
any
case
than.
F
So
I
haven't
observed
that
I
have
not
observed
that
it's
I
think
we
have
it's
either
it
is
an
equal
or
or
better.
Okay,.
A
B
B
We
share
with
you
that
the
preliminary
data
out
of
this-
but
this
is
what
this
is,
what
we
have
measured
in
using
real-life
implementation
and
not
dummy
code,
so
using
real-life
implementation,
which
we
check
that
and
if
you
have
some
stuff
that
you
haven't
considered.
Probably
we
should
include
that,
but
or
anyway,
it
seems
this
seems
the
case.
It
seems
that
you
can
get
slightly.
D
G
B
So.
That's
to
me
that
kind
of
reason,
not
necessarily
I,
don't
know.
I
am
like
a
some
of
the
code
that
I've
seen
for
this
monkey-patching
I
would
at
least
on
the
oldest
old,
that
you
know
there
was
no
chance.
This
was
running
decent
on
trees,
notes
and
I
haven't
seen,
I,
don't
know.
This
is
my
my
take
on
I'm.
That
was
my
explanation.
B
B
Yeah
yeah,
we
have
we've
done
some
some
measurements,
so
I
will
share
with
all
of
you
before
before
publishing.
So
at
least
the
approach
can
be
validated
to
some
extent,
but
that
was
we
have
some
of
the
some
of
the
things
if
you
have
seen
where
with
monkey-patching,
where
I
should
like
30%
even
but.
B
B
B
Conditions
for
it
to
be
moved
out
of
experimental
if
it
can
improve
it
will
improve
absolutely,
but
that's
a
second
level.
I
wouldn't
hold
it.
So
is
this
something
then
it's
getting
discussed
at
TSC,
no
I
haven't
I'm,
just
flagging
and
talking
about
this
data.
Now
this
data
is
now
no
I
mean
just
a
sing
hoax
and
it's
experimental.
No,
no.
A
B
D
D
Diagnostic
working
group
should
recommend
to
the
TSE
what
should
be
done
and
yeah,
but
I.
Don't
think
this
working
group
has
consensus
on
whether
it
should
move
out
of
experimental
and
I
guess.
The
first
step
is
what
they
all
said
in
doing,
that
would
be
to
verbalize
what
are
the
precise
requirements
and
then
maybe
you
can
have
a
discussion
about
whether
it's
ready
to
go
out
of
experimental.
A
There's
still
there's
nothing
that
says
like
to
get
out
of
experimental.
We
need
to
do
the
following,
so
it
sounds
like
that's
the
list
that
we
want.
There
are
some
things
in
particular
that
haven't
been
done
in
terms
of
understanding
earth
impact.
Understand
there
colorants
level
of
that
there's
a
specific
thing
about
this
trigger
async
ie
change
and
whether
it's
cember,
major
or
minor.
G
D
A
A
B
D
G
B
Me,
it
seems
to
me,
is
this
alone
seems
it's
a
condition
to
exist,
experiment
out
to
some
extent
like
it's,
it's
a
basic
condition
like
this
fact
alone.
It's
this
functionality
is
needed
by
the
platform
to
run
so
it
we
should
at
least
flag
it
as
stable,
and
if
you
want
to
change
it,
it's
a
somber,
major
change,
I'm.
A
Bingo
yeah
I,
oh
I
own,
that
toy
yeah,
yeah,
yeah,
I.
Think
and
to
be
honest,
it's
like
my
take
is
this
is
something
that
spans
note.
I
mean
it's
applicable
to
the
browser
as
well.
My
my
gut
is
that
there's
language
constructs
here
and
VM
implementation
stuff
to
make
this
a
really
ear,
consistent,
understandable
story
and
I'm
not
ready
to
go
there
yet.
But
that's
what
my
guts
telling
sorry
I'm?
A
There's
a
separate,
github
repo.
We
tried
to
take
some
of
this
stuff
that
Marc
was
working
on
in
that
that
academic
paper
and
then
trying
to
still
it
down.
You
know
it
is
effectively
trying
to
say
here's
a
conceptual
model
to
think
about
asynchronous
context,
and
we've
got
PR
up
there
for
some
changes
in
terminology.
That
I
think
make
this
a
little
bit
more
accessible,
I
tried
to
CC
the
node.js
Diagnostics,
but
that
didn't
work
for
some
reason,
because
it's
a
separate
repo,
so
I'll
just
paste
a
link
here.
A
A
The
what
basically
we
were
defining
now
is,
you
know
a
few
different
terms.
I
think
one
is
a
continued
raishin
we're
a
continuation
is
a
function
that
gets
passed
into
as
a
parameter
into
some
other
function,
and
it's
going
to
be
invoked
later
in
some
separate,
asynchronous
context.
Right.
A
continuation
point
is
a
function
that
takes
a
continuation
as
a
parameter.
A
So
the
example
there
I
think
is
you
know,
set
timeout
would
be
a
continuation
point
and
you
would
pass
it
a
continuation,
and
then
you
know
the
the
linking
point
or
link
context
is
whenever
that
continuation
is
constructed
or
passed
into
this
continuation
point.
We
changed.
We
previously
talked
about
linking
context
and
causal
context.
A
That
is
at
these
different
points
in
time.
There's
events,
these
events
can
be,
you
know
constructed
into
a
dag.
This
dag
can
be
traversed
sort
of
get
you
all
of
the
functionality
that
you
would
need
to
build.
On
top
of
this,
a
zones
API
or
continuation,
local
storage,
API
or
a
secure
handling,
long
stash
whatever
it
is
that
you
wanted
to
do,
but
I
think
the
starts
to
get
us
to
sort
of
a
formalized
set
of
terms
and
semantics
and
then
to
Ally's.
Last
point.
B
A
Where
inside
of
the
host,
do
you
need
to
start
plugging
stuff
in
kind
leverage?
This
thing
now,
we've
got
some
small-scale
examples
here
that
I
think
are
a
little
easier
than
node,
probably
to
kind
of
wire
all
that
up,
we're
probably
going
to
be
playing
with
that,
hopefully,
in
the
coming
months
month
month,
singular
months
chloral
may
be,
and
it
should
inform
some
of
the
thinking
around
this.
A
A
B
B
E
H
A
Yeah,
so
that's
that's
great
I
think
there's
there's
one
specific
effort
which
is
there's.
You
know,
there's
a
bunch
of
APM
vendors
that
need
to
go
in
and
monkey
patch,
a
bunch
of
things
and
there
there
was
a
goal
to
try
and
get
on
some
shared
implementation
of
monkey
patching
with
some.
You
know,
pub/sub
model,
that
you
know
libraries
can
kick
up
events
that
have
interesting
data
and
then
you
know
subscribers
can
listen
to
that.
There's
been
some
talk.
A
I
know
internally
here
at
microsoft,
there's
been
some
talk
about
open
census
and
I
think
the
goal
is
to
sort
of
have
this.
This
library,
you
know
the
monkey-patching
thing
be
there
and
then
on
top
of
it.
If
somebody
wanted
to
layer
on
top
of
that,
some
open
census,
integration
stuff,
they
could
do
that
I
assume
likewise
open
tracing.
A
Somebody
could
do
that
as
well
yeah,
that
effort
to
sort
of
solidify
that
it's
like
people
talked
about
it
and
it
hasn't
seen
a
whole
lot
of
traction
and
but
it
comes
up
yeah
in
the
context
of
these
these
working,
your
things
we
pulse
on
the
status
of
it.
So
if
you
want
I
think
this
specific
issue
there
right
now
is
just.
C
In
the
meantime,
I
share
the
link.
I
have
some
experience
with
open,
lacing
and
OGS.
We
are
not
using
open
tracing
at
Netflix,
but
let
me
know
if
you
have
a
question.
This
is
very
interesting.
Yeah
I'll
definitely
take
a
look
at
this.
It's
I
made
this
repository
half
a
year
ago,
so
it's
probably
not
up
to
date,
but
then
it
was
working
well.
H
We're
sort
of
just
turning
our
attention
back
around
to
JavaScript
now,
which
is
why
we're
interested
in
kind
of
getting
up
to
speed.
You
know
both
like
what
are
node
specific
efforts
that
are
going
on
and
what
are
JavaScript
based
efforts
that
are
going
on
that
be
applicable
in
the
browser.
Does
he
you
stared
something
else?
Yes,.
A
So
I
think
this
cific
issue
here
is
this
issue
180,
which
is
what
I
was
talking
about,
where
you
know
there's
a
shared
monkey
patch
thing
and
then
on
top
of
those
api's,
you
could
layer
in
something
that's
going
to
do
in
tracing
specific
stuff
or
open
census
or
whatever
eight
things
sometimes
come
up.
What
I
think
the
key
thing
yeah?
The
key
thing
is
to
make
sure
that
these
applications,
like
sort
of
you,
know
peer
posted
or
any
of
you.
A
What
these
ATM
vendors
need,
or
what
you
would
need
to
produce
valid
open
tracing
messages
would
work
with
whatever
the
monkey
patching
pub/sub
model
is
producing
right,
yeah
and
that's
missing
a
driver
right
now.
This
issue,
180,
is
just
kind
of
lagging
a
little
bit,
so
it's
like
feel
free
to
kind
of
step
in
there.
I
can
provide
some
context.
I
don't
have
cycles
to
to
drive
it
at
the
moment.
I.
A
H
A
Oh
check
out
those
those
links,
yeah
sure,
let
me
know
actually
no
but
yeah
so
in
in
JavaScript.
A
You
can
overwrite
functions
right,
and
so,
when
you
have
an
object,
so
you've
got
like
a
MongoDB
driver
on
and
you
you
want.
You
want
an
event
when
you
issue
a
fine
query
right,
yeah
you
can
take
the
finds.
You
know
you
can
go
into
the
driver
object.
Then
you
can
replace
the
find
method
with
your
own
implementation
that
will
emit
some
data
somewhere
right
and
then
call
the
original
implementation.
Okay,.
A
And
it
is
it's
generally
can
I
mean
it's
it's
highly
useful,
but
it's
generally
considered
brittle
right
because
you're
necessarily
taking
dependencies
on
the
implementation.
Sometimes
you
need
to
dig
into
the
internals
of
some
of
these
libraries,
and
so
the
general
goal
is
to
get
away
from
that
in
the
other
piece
here.
A
Is
that
all
the
different
APM
vendors
need
to
go
off
and
do
this
right,
and
so
they
end
up
redoing
they're
all
doing
the
same
thing,
and
so
the
end
result
is
that
ideally
we'd
be
in
a
position
where
there
was
a
shared
single
source
of
monkey-patching.
That
would
produce
some
data
and
raise
that
data
on
a
message.
Bus
and
then
the
consumers
of
this
either
the
APM
vendors
or
something
like
open
tracing,
could
listen
to
that.
A
H
H
Great
that
the
dynamic
I
mean
that's
it's
interesting,
but
we're
kind
of
focused
on
is
more
when
you,
if
you're,
trying
to
trace
your
code
right
you're
trying
to
it's
all
about
context
propagation.
So
the
the
core
problem
is
is
propagating
context
first
on
these
RPC
hops,
so
and
in
propagating
context
down
through
the
program
to
the
next
RPC
hub,
and
so
the
fundamental
question
there
is
we
a
node
is
like
how
does
that
context?
Propagation
work,
not
so
much
dynamic
monkey
patching,
but
you
know
real
context
propagation.
H
A
Not
so
much
with
an
RPC
call
as
it
is
internally
inside
of
nodes,
so
the
problem
there
is
that
in
in
JavaScript
programs,
it's
JavaScript
single
threaded
right,
so
you
know
there's
a
lot
of
these
callback
passing
styles
right.
That
is,
you
say,
I'd,
say
I
want
to
read.
Some
data
read
some
data
from
a
file
and
when
that
data
is
read,
have
the
runtime
call
this
function
and
that
stuff
gets
queued
up
on
and
it
gets
invoked,
synchronously
right,
yeah.
A
E
A
H
But
it
so
that
does
not
cross
process
boundaries,
but
what
happens
is
a
message
comes
in
through
an
RPC
call
right
tracing,
oh,
let's
just
just
to
be
clear.
For
me,
tracing
is
just
logs
with
request
level
indices,
sure
essentially
right.
That's
like
basically
it,
and
so
when
you're
logging,
you
just
have
to
have
the
right
indices,
getting
stamped
onto
that
log.
Yatta
Yatta.
H
Everything
else
is
really
white
whatever,
but
that's
the
core
thing,
and
so,
when
something
comes
through
an
RPC
call,
you
need
to
be
able
to
extract
whatever
those
indices
are
from
metadata
on
the
RPC
call
sure,
and
then
your
logging.
But
then,
as
you
log
and
go
through
the
program,
you
have
to
have
a
way
of
propagating
within
the
program,
those
identifiers
so
that
all
the
logs
you're
doing
get
come
off
of
that,
and
that
to
me
is
where
something
like
async
contacts
would
would
come
in.
It
looks.
A
Like
the
API
yeah
would
be
necessary,
I
mean
async.
Contacts
would
enable
something
like
continuation,
local
storage,
which
would
enable
you
to
when
you
receive
an
inbound
HTTP
request
to
pull
some
header
data
to
say
like
yes,
this
is
my
request,
identifier
and
then
propagate
that
along
a
series
of
asynchronous
invocations
such
that
you
then
make
an
outbound
RPC
call.
You
can
take
that
same
identifier
and
stick
it
in
your
ID
chain
right.
Yes,
so
they
all
kind
of
relate
like
you
need
the
async
context.
A
Yes,
so
that
you
can
propagate
state
across
asynchronous
boundaries
inside
the
process.
The
question
then
becomes
as
well.
You
know
say:
you've
got
something
inbound
on
an
HTTP
header
and
you
need
to
send
it
out
bound
on
some
other
RPC
header
like
how
does
how
do
you
do
that
in
an
open
tracing
way,
or
how
would
you
do
that
in
an
open
census?
Way
right,
oh
yeah
and
I.
Think
that's
some
of
the
where
we
were
talking
about
what
is
the
monkey
patching
stuff
and
how
does
that
all
plug
in
so
yeah?
A
H
Don't
think
there's
yeah,
we
don't
think
there
should
be
monkey
patching
or
at
least
I,
don't
think
there
should
be
monkey
patching
for
this.
This
core
part
of
actually
propagating
those
identifiers
and
injecting
and
extracting
them
you,
we
kind
of
think
you
should
not.
If
you
can
monkey
patch
them
okay,
but
that
you
should
just
do
that.
Basically,
yeah.
A
A
One
of
these
applications
that
would
just
automatically
propagate
all
of
these
things
right
and
is
that
the
kind
of
thing
that
then
becomes
sort
of
an
onerous
task
for
the
end
user
or
not
I,
certainly
think
it
would
be
interesting
from
the
Diagnostics,
because
I'm
assuming
this
comes
up
a
lot
in
like
these
micro
service
applications
where
people
are
wanting
to
trace
requests
from
one
service
to
another
service
to
another
service.
Exactly
on
I
assume,
it
would
be
a
really
interesting
exercise
for
the
nodejs
Diagnostics
working
group,
just
kind
of
say
like
hey.
A
What
does
it
mean
for
somebody
to
use
open
tracing
inside
a
canonical
node
app?
What
does
that
even
look
like
right,
yeah
and
for
somebody
to
start
pulling
the
thread
on
that
and
being
like?
Oh
yeah,
this
parts
easy
this
parts
hard.
This
breaks
down
here:
I
lost
some
state
there
or
whatever
those
things
are.
If
you
wanted
to
do
that
I,
you
know
I
totally
encourage
you
to
do
it
and
we
can
certainly
pulse
on
it
fear
and
part
in
in
the
working
group
meetings.
A
You
know
you
can
open
an
issue
in
the
Diagnostics
nodejs
Diagnostics
github
repository,
and
then
you
can
start.
You
know,
you'll
get
people
to
chime
in
and
pile
in
there
I
don't
know
that
you'll
get
people
to
do
work,
you'll
get
people
to
share
opinions.
Yeah,
you
know,
that's,
that's
the
you
know,
I,
don't
know
you'll
get.
You
know
one
piece
of
work
for
every
20
opinions
or
whatever,
whatever
that's
fine,
yeah.
H
H
I
know
where
to
go
grab
these
identifiers
from
so
you
can
just
log
away,
and
if
these
things
are
they'll
just
automatically
get
integrated
because
there's
some
context,
propagation
mechanism,
that
is
explicit
and
you
can
go
grab
and
then
grab
stuff
out
of
a
bag
there
right.
So
that's
easy.
The
the
part
that's
hard
is
just
whatever
code
is
actually
injecting
and
extracting
this
stuff
from
headers
and
then
instrumenting
within
those
libraries.
H
A
H
A
The
MongoDB
drivers
and
they're
talking
to
a
MongoDB
service
in
AWS
and
AWS
has
its
own
sort
of
correlation
tracking
thing
that
they
use
and
they
expect
it
to
work
with
in
a
certain
way
right
and
another
person
wants
to
use
that
same
library,
but
they
want
it
to
work
with
Azure
right
yeah,
and
so
at
that
point
like
how
do
you
have
one
single
library?
That's
actually
gonna
sum
both
people
can
use
and
then
you
can
compose
it
with
the
right
chunking
stuff.
A
That
knows
how
to
add
correlation
logic
or
the
AWS
protocols
and
knows
how
to
add
correlation
or
the
AWS
service
and
the
other
one.
That
is
how
to
add
the
right
correlation
IDs
for
the
azure
requests
right,
and
so
that's
where
we're
trying
to
get
to
this
one.
Eighty,
which
is
that
the
MongoDB
driver
is
going
to
kick
up
some
events
right
and
say
like
hey.
This
is
happening
and
I
know
this
is
some
stay
and
then
observers
have
the
opportunity
to
plug
in
and
either
mutate,
some
of
that
state,
add
headers
or
whatever.
A
H
H
Does
every
vendor
or
every
tracing
program
have
to
then
create
dynamic
hooks
for
every
single
version
of
every
single
library,
because
and
then
the
other
issue
is
like
the
overhead
of
like
a
general-purpose
monkey-patching
solution
versus
someone.
Just
has
an
API
for
explicitly
doing
these
like
three
steps,
but
that
API
doesn't
halt.
That
API
is
such
that
it's
like
a
two-sided
API
people
can
bind
to
that.
It
sort
of
relates
to
what
Ali
was
saying.
It's
like.
H
A
Yeah
and
that's
one
of
the
things
we're
trying
to
address
with
this
one
80
issue
is
that
we
expect
there
to
be
a
a
pub
sub
model
where
you
can
basically
say
if
somebody's
listening
for
my
specific
event
then
publish
some
data
on
the
channel,
and
then
somebody
comes
on
the
other
side.
They
can
say,
like
I,
want
to
listen
for
events
of
this
type
right
and
then
the
you
know.
A
So
right
now,
there's
there's
one
thing:
that's
in
place,
which
is
called
diagnostic
channel,
which
is
a
Microsoft
Project.
That's
on
that
and
that
is
sort
of
agnostic
in
terms
of
how
asynchronous
context
propagation
works.
A
So
you
can
plug
in
a
different
implementation
of
a
library
to
ensure
that
you
know,
and
as
long
as
it's
like
you
meet
some
API,
which
is
like,
what's
my
current
context
or
or
something
for
my
this
execution
context
and
get
a
you
know,
you
want
a
key
value
store
across
a
synchronous,
invocations
right
and
as
long
as
you
provide
that
semantics,
then
you
can
plug
in
whatever
implementation
you
want.
A
sneak
locus
is
one
implementation.
A
H
A
A
I
think
that's
fine.
You
know
it's
feel
free
to
like
reach
out.
If
you
have
questions
you
know
it's
like,
if
you
want
to
add
things
to
the
agenda
or
something
just
you
know,
I
think
I've
got
the
permissions
to
do
that.
I,
don't
know
that
everybody
does
but
or
if
you
want
issues
and
what
we
generally
do
is
we
have
an
issue
open
in
a
Diagnostics,
nodejs
Diagnostics
and
it
gets
tagged
and
then
it
comes
up
here
and
we
talk
about
it.
People
can
give
status
and
that's
probably.
A
Way,
yeah
at
first,
you
might
get
a
lot
of
like
feels
like
nobody's
interested,
but
then
I
think
you'll
start
seeing
some
some
traction
and
I
think
it
would
be
good,
like
I
feel
like
that
group-
and
you
know
partially,
my
fault
just
like
haven't
been
this
involved
over
the
last
couple
months,
but
you
know
it's
getting
a
it's.
We
can
use
a
shot-up
moment,
you
know
so
sure
I'm
gonna
do
like
hey.
We
were
making
traction
on
X,
Y
or
Z
and
I.
Think
that
would
be
a
really
positive
thing.
H
We
can
do
a
mock
up.
I.
Think
your
suggestion
is
great
of
being
like
hey,
we
gotta,
like
hook
all
this
stuff
up
together.
We
kind
of
think
this
approach
based
on
top
of
async
context,
and
you
know
it's
like
native
API
native
package.
Instrumentation-
is
like
the
most
efficient
way
to
make
everybody
happy
and
here's
how
that
works,
and
then,
if
you
wanted
to
like
monkey
patch
on
top
of
that
to
decorate
this
thing,
you
can
also
do
that.
So
I
think
we
could.