►
From YouTube: ASP.NET Community Standup - November 20, 2018 - .NET Core 2.2 Diagnostics with EventPipe
Description
Special guest Andrew Stanton-Nurse discusses and demos the new EventPipe features in .NET Core 2.2 and some prototype accompanying tools that can be used to help diagnose issues in running applications. First look at dotnet-dump, dotnet-collect, and dotnet-analyze.
Demo code available at https://github.com/aspnet/AspLabs/tree/master/src/DotNetDiagnostics
A
A
straight
two
one
we
know,
but
there's
no
one
here
so
generally,
we'll
just
wait
a
couple
of
seconds,
sorry
for
people
to
file
in
but
I
trust
that
everything
is
live
and
good,
as
the
screen
tells
me
right
now.
Yes,
I've,
never
trusted
every
time.
I
start
the
show
by
just
going
I
think
we're
live.
It
says
we're
live
and
then
I
watch
it
back
later,
and
it's
usually
captured
like
the
ten
seconds
before
that
as
well.
A
B
A
A
A
A
B
B
A
A
D
B
Go
ahead:
John,
alright,
I'm
gonna
start
with
some
options
and
options,
validation
fund.
So
recently
we
talked
about
option
validation
and
you
pointed
out
an
asp
net
core
to
two
feature
which
is
built-in
option:
validation,
so
I
love
how
the
community
watches
they're
involved.
So
here's
Steve
Gordon,
you
know
reference
at
and
he
dug
in
and
wrote
up.
You
know
looked
at
the
code
and
wrote
up
some
stuff,
so
this
is
really
neat,
so
he
wrote
up.
B
You
know:
here's
an
example
I'm
adding
in
the
some
validation
you
know,
adding
in
a
lambda
to
validate,
and
you
know
require
one
setting
for
another
one
etc
like
setting
three
is
required
when
setting
two
is
present
and
so
and
then
talking
about
you
know
kind
of
different
options
for
how
to
set
that
up.
So
when
so,
for
instance,
here
he
goes
through
and
says
like
by
default,
you're
going
to
get
an
exception,
but
you
can
go
in
and
like
set
the
message
for
it
as
well.
B
A
B
B
A
How
the
validation
attributes
work
right,
so
the
validation
attributes
flow
is
that
they
have
two
ways:
I
think
they
have
a
method
and
then
they,
depending
on
the
flow
that
you're
using
them,
and
they
can
throw
a
validation
exception.
Now.
My
understanding,
though,
let
me
think
so
this
is
using
the
new
to
to
stuff
I
need
to
think
back
to
when
I
saw
this
demo.
I
may
not
be
able
to
answer
authoritative
lis
on
this
one.
That's
my
post-ops,
sorry
and
I'd
have
to
look
at
the
code.
A
A
B
A
A
A
B
A
Difference
is
basically
one
is
deprecated
and
one
isn't:
okay,
now
I'm
being
a
little
facetious,
but
it's
basically
true
I
think
we
I
can't
remember
the
order
Angie
drew,
which
one
is
the
one
that
you're
supposed
to
use.
No,
we
Michigan
has.
If
you
look
through
our
source
code,
we
basically
use
only
one
now,
one
of
them
supports
names,
I
think
and
the
other
one
doesn't
is
the
one
that
supports
names
is
the
one
that
you
should
be
using
and
I
always
forget
which
one
it
is
I
have
to
look
it
up.
A
Okay,
oh
I,
open
snapshot,
it
says
right
there
named
options
are
always
scoped
with
directions,
snapshot
so
I.
Think
you're
supposed
to
use
eyerection
snapshot
for
everything
options.
Monitor
was
the
thing
that
was
around
in
the
first
version,
and
then
we
introduced
snapshot
later.
Okay,
I
think
I
think
that's
the
right
order,
but
I
so.
C
D
B
A
A
A
Okay,
I
thought
all
named:
options
were
singleton,
okay,
there's
in
like
once,
you
have
a
named
options.
That
instance
is
singleton
for
the
app
and
then
there's
a
default
named
options,
which
is
one
with
no
name
which
is
a
singleton
for
Europe
as
well.
So
if
you
register
an
options
without
a
name,
it
gets
a
name
of
like
nothing.
Basically
right.
C
B
Like,
for
instance,
here
this
guy's
saying
I
often
snapshots
great
for
getting
injected
into
a
scoped
or
transient,
and
then
I
option
monitor
for
singleton,
okay,
honestly
I,
don't
know
okay,
so
interesting
post.
This
is
cool
moving
on
the
azure
DevOps,
so
here's
some
hands-on
labs
these.
These
are
like
newly
released,
an
updated
stuff
to
cool
ones.
In
here
this
one
is
a
docker
based
application.
B
There's
a
neat
thing
here:
there's
this
Azure
DevOps
demo
generator.
So
this
will
actually
like
spin
up
and
provision
stuff
for
you,
which
is
neat,
and
then
this
goes
through,
and
this
lab
takes
you
through
using
Azure,
DevOps
and
you're,
actually
deploying
it
to
a
Linux
as
your
app
service.
So
this
kind
of
takes
you
all
the
way
through
that
and
deploying
the
healthcare
sample
so
that
one's
kind
of
neat
there's
also
one
in
here-
the
that's
interesting.
This
says:
Shane
had
done
this
and
this
is
or
this
is
referencing.
B
Some
work
Shane
did
with
nerd
dinner.
So
this
is
the
kind
of
asp
net
court
or
asp
net
classic
or
whatever
previous
version
MVC
with
a
spear
with.
So
this
is
NBC
for
nerd
dinner,
but
this
takes
you
through
deploying
that
out
to
to
docker
and
azure
container
registry
and
stuff,
so
yeah,
really
nice
read
nice
labs
here
and
there
you
know
just
published,
so
that's
cool.
B
So
this
is
continuing
with
ahead
series
here,
he's
got
EF
core
migrations
in
the
asp
net
core.
Taking
you
all
the
way
through,
you
know
explaining
what
they
are
going
over:
the
different
migration
commands
and
then
including
some
stuff
at
the
end,
which
is
important
things
like
you
know,
options
for
running
and
production
and
how
you
know
that
can
do
how
that
works
as
well
as
things
like
reverting
migrations.
So
that's
helpful
that
was
in
a
recent
workshop.
I
was
teaching.
B
Okay
is
peanut
core
2
to
health
checks.
Thomas
does
a
really
nice
overview
here
talking
about
what
they
are
digging
into
some
examples
with
things
like
database
health
checks
showing
the
examples
of
you
know
like
here's
an
example
and
then
when
we
hit
it,
here's
what
we'll
get
back.
You
know
we'll
get
a
200
and
healthy
cool.
A
B
B
A
So
yeah
we
are
as
part
of
doing
health
checks.
We,
you
know,
we
spoke
to
the
bee
pulse
folks,
we
didn't
want
to
have
to
go,
and
you
know,
create
a
library
of
pre-canned
health
checks.
We
kind
of
expected
like
from
the
outset.
We
were
kind
of
pretty
clear
that
we
wanted
the
community
to
do
that,
because
we
would
never
agree
on
what
the
right
ones
to
put
in
the
Box
were
I.
We
were
like.
A
Maybe
we
should
have
like
a
disk
space
wine
and
a
memory
one
and
CPU
and
stuff,
but
the
reality
is
big:
possibility
existed,
they
had
a
really
good
library
of
sort
of
checks
and
they
have
this
UI,
which
is
great,
and
so
we
decided
that
yeah.
Why
would
we
do
any
of
that?
Stuff
will
just
make
the
new
sort
of
bit
the
new
di
thing.
A
The
middleware
will
plug
that
in
and
then
we
ask
the
B
post
beep
pulse,
focuses
that
if
they
basically
be
willing
to
replac
their
stuff
on
top
of
the
health
check
system-
and
they
did-
and
so
now
you
kind
of
get
the
best
of
both
worlds.
You
have
the
core
health
check
system.
With
this
capabilities
in
terms
of
plumbing
in
the
middle,
we're
climbing
into
di
you
can
get
stuff
out,
ask
it
to
do
checks
and
the
sort
of
we
set
the
primitives
and
then
be
pulse,
provides.
B
Yeah
I
left
that
kind
of
coordination
and,
like
you
said,
we
build
the
infrastructure
and
they
kind
of
the
primitives
and
stuff,
and
then
they
build
on
top
of
it,
and
this
is
cool.
I
haven't
seen
this
UI
and
they
have
a
docker
image
for
that
as
well.
So
that's
kind
of
neat
all
right.
Here's
a
nice
overview
on
creating
a
react
application.
So
this
starts
with
the
file
new
react
app.
It
shows
kind
of
what
happens
when
you
run
it
so
like,
for
instance,
it's
running
on
top
of
the
react
server.
B
So
it's
actually
you
know
doing
that
and
he
talks
about.
You
know
the
that
it
may
be
that
there
this
is,
you
know
using
the
npm
script.
If
you
want
to
run
directly
without
running
that
development,
the
react
development
server
as
well.
You
can
point
directly
at
localhost,
so
you're
not
doing
that
kind
of
react,
build
every
single
run,
I'm
so
kind
of
the
differences
there
and
then
kind
of
going
through
and
talking
about,
publishing
and
deploying.
So
this
is
just
kind
of
a
nice
you
know
taking.
B
B
This
is
the
first
in
a
series,
I
believe
if
a
blog
post
digging
into
that,
so
explaining
a
you
know
with
Surfer
GC,
when
you're
running
with
a
48
proc
machine,
you've
got
thirty
one
megabyte
overhead
per
proc,
you
know
it's
going
to
add
up
and
so
then
going
forward.
I
believe
the
the
idea
is
like
looking
at
what
are
the
actual
defaults.
You
should
for
a
larger
proc
machine,
yeah.
A
That's
in
trident
seen
that
post
there's
a
bunch
of
internal
threads
before
Nick
had
tweeted
about
what
they
were
seeing
when
they
were
porting.
Some
of
the
the
stack
overflow
systems
to
not
net
caught
I,
don't
know
what
system
it
was
Nick's
on
the
call
he
might
tell
us.
It
may
have
been
their
custom
WebSocket
server
that
they
were
seeing
this
in
or
something
else
tagging
it
in
one
of
their
components.
It's.
A
Threads
internally,
where
we
were
asking
ourselves
questions
along
the
lines
of
more
along
the
lines
of
this
title,
which
is
what
happened?
What
does
it
mean
to
try
and
run
dotnet
core
in
a
container
that
has
a
high
low
memory
constraint,
because
it's
pretty
common
in
container
scenarios
that
you
won't
just
a
deployment,
contain
you'll,
set
a
limit
and
you'll
say:
hey.
This
container
can
only
use
so
much
CPU.
We're
gonna
use
this
so
much
RAM
and
we
had
had
some
and
Nick
confirmed
it
was
the
WebSocket
server.
A
So
some
we've
had
some
customers
who
had
tried
to
like
Ronnie's
Burnette
core
in
a
container
and
set
the
memory
limit
to
like
200
megabytes
or
even
less,
and
then
was
surprised
that
either
it
didn't
honor
that
memory
limit
or
they
got
bad
behavior
like
the
app
wouldn't
start
or
the
app
would
stop,
but
they
really
couldn't
do
anything
reasonable.
And
so
we
have
a
set
of
things
that
were
investigating
for
the
next
version,
of.net
core
to
basically
try
and
understand
these
types
of
scenarios
better.
A
C
B
A
It's
not
that
it
doesn't
support
limits
like
when
you
run
in
is
with
dotnet
framework
or
dotnet
core,
and
you
set
memory
limits
for
the
app
pool.
Those
are
controlled,
using
what
are
called
Windows
job
objects
and
they
that
is
all
honored
by
net
when
run
using
those
parameters,
and
so
you
can
constrain
the
size
of
your
process
in
is,
and
that
will
be
honored.
But
the
type
of
memory
limits
that
would
people
try
to
apply
in
containers,
I
think
it's
fair
to
say,
was
quite
a
lot
lower.
A
Then
I
think
we'd
seen
people
attempt
to
do
before
on
these
seven
and
that's
just
the
nature
of
people
deploying
containers
and
micro
services,
and
they
might
have
had
a
go
application
where
they
could
successfully
run
something
with.
You
know,
a
very
small
amount
of
memory
and
they
tried
to
do
the
same
thing.
We've
got
there
so
we're
investigating
this.
We
want
to
sort
of
I
want.
I
won't
make
an
announcement
about
what
we're
doing,
because,
frankly,
we
don't
know
what
we're
doing
it
could
be
a
lot
of
things
we
could.
A
We
may
have
to
make
changes
to
serve
a
GC
to
make
it
work
better
in
these
lower
memory
constrained
environments.
It
may
be
that
we
just
make
recommendations
like
hey,
don't
use
server
GC.
If
you
want
to
run
at
under
500
Meg,
you
should
do
use
workstation
GC.
Instead,
maybe
we'll
add
capabilities
to
serve
a
GC.
Sarah
GC
is
highly
parallelized,
and
so
some
folks
may
not
realize
that
some
of
the
rules
where
they
think
about
oh
I,
understand
this.
A
Some
of
them
aren't,
and
so
a
lot
of
that
stuff
I
think,
is
being
explored
as
part
of
this
effort
and
then
hopefully,
we'll
see
some
useful.
You
know
changes
come
out
of
it,
but
may
only
as
always
is
great.
It
sort
of
you
know
capturing
a
whole
bunch
of
stuff.
That's
happened
as
well
as
this
and
doing
some
blog
post.
So
this
is
good
to
see.
B
This
once
this
is
helpful,
this
is
a
visual
studio
extension
there's
one
for
visual
studio
code
and
visual
studio.
This
is
paste
JSON
as
code,
and
there
is
a
built-in
feature
in
Visual
Studio
for
pasting
as
code,
but
this
is
kind
of
this
is
built
on
top
of
quick
type,
and
you
know
I'd
run
into
this
recently,
where
I
had
to
use
quick
type
and
I
was
trying.
B
B
So
it's
nice
to
know
this
is
available
for
visual
studio
and
Visual
Studio
code,
alright,
peach
pie,
so
this
is
neat
peach
pie
has
an
extension
for
visual
studio
now,
which
is
cool,
so
peach
pie,
yeah,
so
peach
pie
allows
you
to
run
PHP
on
top
of
asp
net
core
as
middleware,
which
is
which
is
pretty
fabulous,
and
so
here
now
there
are
project
templates.
You
can
manage
dependencies
integration
with
tests,
publishing
kind
of
all
the
stuff
debugging.
So
this
this
is
pretty
phenomenal
with
what
the
peach
pie
team
continues
to
crank
out.
B
So
that's
pretty
neat
kisum,
so
I've
mixed
feelings
about
this
I'm
interested
in
your
thoughts.
It
should
build
out
some
validation
controls
using
Blaser
okay.
So
if
you
look
at
these
controls
just
you
know,
we've
got
a
range
validator,
a
compare,
validator,
etc.
If
you
look
at
the
kind
of
end
result
I'm
scrolling
down,
so
here
we've
got.
You
know
these
validators.
A
A
B
The
one
hand
I
think
it
is
helpful
for
kit,
like
I,
like
talking
to
people
that
have
existing
apps
that
are
built
heavily
on
the
component
model.
I
do
like
seeing
how
components
snap
together
and
how
they're
kind
of
so
flexible,
but,
on
the
other
hand,
I
think
razor
has
some
pretty
decent
validation
already
set
up
and
like
with
validation,
attributes
and
stuff.
No.
A
Haven't
got
they
haven't
built
the
validation
model,
yet
that's
part
of
the
300
work
to
do
razor
components.
One
of
the
big
work
items
is
to
design
and
implement
a
validation
system
for
doing
form
validation.
Now
the
other
spar
frameworks
have
gone
through
various
schools
of
thoughts
on
the
I've
had
a
few
discussions
about
it,
angular,
even
within
the
1x
time
frame.
A
A
Code
and
then
that
flows
into
the
UI
of
our
bindings
and
I
think
there
are
pros
and
cons
to
both
like
this
approach.
The
web
forms
approach
is
very
much
an
additive
sort
of
component
based
validation,
where
you
add
a
validator
and
it's
very
separate
to
your
model
or
separate
to
the
control,
but
then
kind
of
they
might
hook
themselves
together,
like
they
did
when
web
forms.
But
then
a
web
forms
in
four
five
six
I
think
it
was.
We
added
model
validation,
support
which.
B
A
B
A
Mvc
I
was
actually
the
PM
for
the
model
validation
in
web
forms,
which
is
why
I
remember
yeah
and
then,
if
you
look
at
stateful
or
UI,
I,
stateful
UI
systems
or
component
based
systems
like
WPF
and
WinForms,
they
all
have
various
sort
of
approaches
to
doing
validation,
whether
it's
IR
data
info
in
the
wind
forms.
But
it's
not
a
lot
of
people
use
actually,
but
there
are
built-in
controls
and
mechanisms
for
flowing
validation,
information
from
code
and
data
binding
through
into
the
UI
elements
are
showing
those
values.
A
A
So
you
can
set
CSS
classes
conditionally
based
on
the
model
state
for
the
current
model
stuff.
But
you
know
it's
complicated
because
sometimes
you
want
to
buy
in
the
input
field
to
the
data
type,
but
you
want
the
CSS
class
to
be
on
an
element.
That's
two
parents!
Up
from
that
right.
You
want
it
to
do
bubble
or
not
all
right
to
use
the
WPF
terminology,
so
we'll
figure
all
that
out.
A
That
will
happen
and
we'll
figure
out
what
the
primitive
in
Blazer
is,
that
we
build
that
on
top
off,
like
we
have
those
propagated
events
or
whatever
they're
called
at
the
moment
in
Blazer,
which
might
we
might
build
the
validation
system.
On
top
of
that,
so
you
can
propagate
stuff
up
and
down
I'm,
not
sure,
but
this
is
a
perfectly
reasonable
thing
to
try
and
to
do
because
we
don't
have
one
yet,
and
so
this
basically
members
what
we
did
in
in
yep.
B
A
B
This
is
beautiful,
so
what's
what's
neat
here
is
they're
they're
really
bite-sized
you
can
you
can
grab?
You
know
specific
things.
They
show
a
specific
feature.
There's
examples
here
that
show
kind
of
what's
new,
talking
about
what's
new
between
the
different
things,
yeah,
so
just
tons,
tons
and
tons
and
what's
what's
neat
on
here
to
is
he
says
you
know
we
keep
up
to
date,
updated
almost
daily,
so.
A
A
B
B
Yep
so
neat
stuff
and
people
that
watch
really
closely
this.
This
blog
post
is
exactly
what
Steve
demoed
for
us
on
the
latest.
Blazer
talk,
ok,
so
yeah.
So
when
Steve
was
on,
he
showed
hooking
up
a
theme
info
and
having
this
kind
of
cascade
down
into
a
control,
and
so
he
showed
like
hooking
up
button,
success
and
button
default
and
stuff,
and
so
here
this
this
kind
of
cascades
down,
and
you
get
this
theme
which
sets
the
button
color
to
button
default.
B
A
Believe
my
mind
when
he
demoed
that
in
this
room
yep,
he
just
put
an
if
statement
in
the
middle
of
the
component
and
just
went
back
to
the
browser
after
building
it
and
their
5
min
it
worked
and
I
was
like
yeah
I'm,
mixing
declarative
with
imperative
and
your
components
and
it
old
just
works
was
just
like.
Oh
my
god,
this
is
so
fantastic
yep.
A
B
A
A
Of
stuff
doesn't
work
so
like
I
mean
it
is
the
first
version
you
get
colorization,
you
get
statement,
completion
for
C,
but
the
important
thing
is
you
actually
do
get
intellisense
for
your
c-sharp
as
declared
so
like
it
understands
where
c-sharp
is,
and
it's
like.
Okay,
this
is
C
sharp
in
here
I'll,
give
you
C,
sharp
and
tell
us,
and
so
that's
like
the
building
block,
that
we
had
to
get
working
in
this
code
and
then
we'll
start
adding
things
like
we
get
the
basic
directives.
A
But
then
we
don't
have
tag
helpers
right
now
and
all
that
plumbing
and
stuff
working,
but
that
will
come
and
we
will
add
the
blazer
component
support
as
well,
obviously
as
we
do
with
the
rate
of
component
stuff,
but
we
finally
got
over
the
milestone
of
like
basic
C's
HTML
stuff
works
is
amazing.
Right.
B
A
B
B
A
B
B
A
B
A
So
we
had
some
as
part
of
the
I
can't
remember
if
I
mentioned
this
last
week
with
Hanselman
or
not,
but
you
know
the
previous
week
we
talked
about
all
the
week
before
that.
Whatever
was
announcement
about
the
changes
in
301
of
those
things
was
the
how
that
relates
to
the
lifecycle
of
support
for
a
spinner
core
on.net
framework.
So
the
two
one,
which
is
the
current
LTS,
is
currently
slated
to
be
supported
through
to
2021.
A
A
As
the
other
asp
net
package
based
frameworks,
a
spinet,
MVC
5
dot
x
with
API
2x
signal
are
two
directs,
which
means
they're
effectively
supporting
the
definitely
as
its
laid
out
in
the
support
policy.
But
that's
linked
to
so
hopefully
that
I've
been
judging
by
the
responses
and
the
feedback
votes
and
the
glitches
that
you
have
on
your
issue.
There
that
we
got,
but
that
was.
B
A
The
scenario
is
about
Diagnostics.
Anyone
who
is
used
on
a
framework
on
Windows
today
will
know,
there's
a
whole
bunch
of
things
that
you
might
do
to
diagnose
issues
with
your
application
or
to
monitor
an
application,
whether
it's
performance
counters,
to
see
how
much
memory
is
being
allocated.
What
your
threads
are
doing.
A
You
know,
there's
various
tools
and
then
load
those
into
microsoft,
minute
message,
analyzer
or
individual
studio,
or
into
perfu,
or
into
third-party
analysis
tools
or
use.
We
use
your
favorite
third-party
profiler,
like
JetBrains,
trace
or
dot
memory,
and
you
could
use
all
these
things
on
Windows
on
dotnet
framework,
and
then
you
got
to
button
their
corn.
You
go.
None
of
this
stuff
works.
A
Those
was
really
something
you
could
do
on
Windows.
Only
it
wasn't.
We
didn't
have
a
great
story
for
Linux.
We
had
a
story.
There
was
a
github
dock.
There
is
a
tool
that
ships
with
the
runtime
called
proc
was
it
take
the
brunt.
Re
crate
dump,
there's
nothing
on
Mac,
and
but
there
were
caveats
of
all
those
things
like
that
file.
You
couldn't
drag
into
VSO
analyze
it.
You
were
kind
of
stuck
in
the
world
of
using
LLVM
tools
and
all
day.
A
A
A
A
B
C
A
C
A
A
B
B
C
C
C
So,
as
Damian
mentioned,
there's
a
lot
of
tools
on
Windows
that
don't
we
don't
have
an
equivalent
for
them
on
Linux
or
Mac
OS,
and
so
some
of
what
we're
trying
to
look
at
moving
forward.
This
is
for
3,
oh,
but
also
for
beyond.
That
is
trying
to
close
those
gaps,
but
also
go
beyond
where
we
were
with
with
Windows
2,
because
I
mean
we
don't
just
want
to
catch
up
there.
C
C
There's
no
C
I
hear
no
build
yet,
but
we're
just
kind
of
hacking
on
some
tools
and
throwing
them
in
here.
Oh,
that
was
a
big
scroll.
We've
got
a
couple
tools
in
here:
we've
got
dotnet
dump,
which,
as
Damien
mentioned,
we've
got.
There
are
some
tools
on
Linux
that
let
you
create
a
dump,
a
dotnet
dump
that
so
first
off
you
could
you
could
just
use
a
standard
debugger
and
take
it
and
capture
a
memory
dump,
but
they
tend
to
be
very
large.
C
They
tend
to
have
like
every
piece
of
memory
in
the
entire
process
and
general.
You
don't
need
all
that
much
space
dot
net
dump
is
a
tool
we're
playing
with
to
wrap
up
the
windows.
Api
is
for
for
creating
a
memory
dump,
but
also
the
Linux
tools
that
already
exist
and
try
to
make
a
cross-platform
way
for
you
to
just
go
dotnet
space
dump,
process
ID
and
have
it
right
capture
memory.
Dump
people
are
saying.
C
C
C
A
C
Be
on
a
bun,
maybe
they
think
it's
anyway.
It's
all
good.
It's
ok!
So
the
other
thing
Damian
mentioned
is
event
pipes.
So
we
have
this
thing
in
dotnet
called
event
source,
so
you
can
create
a
class
that
inherits
from
event
source.
You
can
define
some
events
on
that
which
is
kind
of
like
logging.
You
basically
can
say
hey
when
something
happens:
I'm
gonna
fire
off
some
event
and
someone
who's
monitoring.
The
application.
Can
capture
that
event
and
look
at
information.
C
C
So
ii,
so
in
cortana,
core
100,
I
think
there
was
a
back-end
built
for
it
on
this
system
called
LT
TNG,
which
is
a
Linux
based
tracing
tool.
So
the
idea
was,
it
was
kind
of
equivalent
to
etw,
but
on
linux,
and
it
would
let
you
collect
these
events
on
linux
and
so
the
you
can
build
these
events
in
your
app,
but
also
the
runtime.
C
It's
a
bunch
of
these
events,
they're
events
for
when
a
garbage
collection
starts
for
when
allocations
happen,
for
when
methods
are
jaded
for
when
thread,
pool,
cue
thread
pool
threads
are
allocated
so
that
existed
in
core
100,
but
it
used
this
system
LT
TNG,
which
didn't
really
work
well
in
containers.
It
had
it
didn't
capture,
stack
traces
which
were
really
useful.
It
was
missing
a
bunch
of
things,
so
we
looked
in
2.0
in
sort
of
the
2-point
hex
wave
to
try
and
build
a
new
system
that
was
cross-platform
that
was
just
dotnet
based.
C
A
A
Stacks
were
just
didn't
know
like
if
you're
on
Linux,
you
use
the
Linux
stuff
and
your
front
Mac
user
Mac
stuff.
You
know,
windows
your
winter
stuff,
so
we
had
ended
up
starting
there,
which
is
why
we
did
the
LT
TNG
thing.
But
what
we
found
is,
as
a
lot
of
customers
were
moving
from
dotnet
on
Windows
to
Dante
on
Linux
right.
They
were
kind
of
lost
in
the
sense
that
we
don't
want
to
do
any
of
this
stuff.
A
A
But
it
doesn't
prevent
it,
so
you
can
all
I
mean
depending
I
guess
it
depends
on
what
you're
doing
you
can
solve
your
venting
from
both
and
then
get
correlation
and
stuff.
There
are
ways
you
can
do
it,
but
we
kind
of
wanted
to
solve
those
most
basic.
These
are
the
top
5
problems
that
customers
run
into
and
maybe
more
than
that,
how
can
we
just
make
some
dotnet
commands
that
make
this
simple.
C
Everywhere,
I,
don't
think
of
it
that
easy!
That's
what
this
gets
to
is
like.
We
have
these
tools,
but
they're
kind
of
hodgepodge
and
and
getting
them
pulled
together
is
kind
of
tricky.
So
we
have
dotnet
dump
and
we
have
this.
This
command
I'm
gonna,
show
in
a
minute
dotnet
collect
what
Don
net
collect
lets
you
do
is
basically
pass
in
a
process
idea
of
a
dotnet
process
pass
in
some
things.
You
want
to
collect
some
runtime
events,
some
of
your
own
events.
This
also
natively
supports
the
mark.
Slipped
extensions
logging
loggers.
C
So
if
you
have
loggers
in
your
system
you
don't
you
can
have
no
additional
providers,
you
can
just
have
the
default
stack.
The
default
stock
web
host
default
builder-
and
you
now
can
use
dotnet,
collect
to
collect
those
log
events
out
of
process
without
requiring,
and
you
can
so.
You
can
build
a
thing
to
monitor
your
app
collect
some
events
and
upload
them
so
somewhere
for
tracking
later,
and
then
I
have
done
that
analyze,
which
is
a
tool.
It
does
a
couple
different
things.
C
We
were
kind
of
playing
around
with
using
it
to
analyze,
dotnet
memory
dumps,
but
I've
also
added
some
things
to
analyze
some
of
these
events.
So
they
look
at
everything
on
one
machine
because
right
now,
the
only
place
we
have
to
view
these
event.
Traces
is
perfu,
which
is
a
sort
of
quasi
side-project
d
kind
of
yeah.
A
C
A
Well,
you
know
we
said
windbg
before
there's
a
bunch
of
very
common
things
like
SOS
commands
that
people
will
always
type
the
same
three
commands
at
the
beginning,
just
to
see
what
they
find
cuz.
Sometimes
you
can
solve
it.
Oh
there's
the
problem.
The
first,
the
second
command
I
write,
I,
see
what
it
is
now
and
it
turns
out
to
be
a
code
bug.
We
want
to
make
that
universal
yeah.
Alright,
let's
try.
C
Some
of
this
stuff
out
so
I've
got
a
simple
dotnet
app
here.
Let
me
scale
up
a
little
bit.
I
think
it's
probably
it
was
pretty
good
yeah,
it's
I've
just
got
us.
I,
just
literally
went
on
that
new
web
app
and
I
put
some
stuff
in
here,
I
added
a
service
and
I'm
pulling
that
service
in
in
my
razor
model
and
I'm
just
calling
get
items
and
get
items,
it's
not
that
exciting
I'm
not
really
doing
anything
real.
It's
kind
of
a
constructed
example,
but
I've
got
some
loggers.
C
I'm
logging,
when
I'm
initialized
I'm
logging,
when
I'm
getting
items
I,
was
playing
around
with
some
things
about
memory.
But
that's
not
really
here
right
now,
but
the
bigger
thing
is
to
show
how
we
can
actually
get
the
stack
traces
out
from
these
events,
and
one
of
the
things
Nick
mentions
is
divide.
B
C
Trace
without
collecting
them
without
capturing
memory
dump
the
advantage
here
is
that
anywhere
you
have
a
log
using
ilogger
or
an
event
using
event
source
which
I
don't
have
a
example
here.
But
there's
lots
of
Doc's
about
that
you'll
be
able
to
get
a
managed
stack
trace
for
the
whole
thing
and
we'll
show
that
in
a
sec.
So
without.
C
Still
running
just
fine
when
you
turn
on
the
providers
as
they're
cold,
they
little
individual
events.
It
does
add
a
little
bit
of
overhead
to
that
code
path
because
it's
got
to
collect
the
stack
trace.
It's
got
to
do
that,
but
it's
only
while
it's
on
and
when
you
turn
it
off
it,
it
goes
back
again
all
right,
so
I've
got
a
little
too
little
terminal
windows
here
on
the
top
I've
just
run.
My
app
and
I've
got
the
process
ID
showing
up
there
and
I'm
gonna
go
down
I'll.
C
I
can
zoom
a
little
bit
there.
We
go.
That's
a
bit
better,
so
I'm,
just
gonna
pull
up
up
command
from
history
here.
So
we've
got
this
tool.
We're
working
on
dotnet
collect
right
now,
I'm
running
it
right
out
of
the
repo,
but
you
can
imagine
this
whole
text
here
would
just
be
replaced
with
dotnet
are.
A
C
B
D
C
Like
that
kind
of
thing,
high-level
things,
so
we've
added
so
in
this
tool
you
can
specify
provider
and
if
you
happen
to
know,
oh
I
want
Microsoft
Windows
dot,
net
runtime
and
I
want
the
keywords.
A
six.
You
know
like
you
can
punch
that
stuff
in
if
you
want
to
configure
it
manually,
but
we've
also
added
the
ability
to
just
have
profiles
like
a
pre-k
educator
and.
C
C
B
C
C
C
C
Yeah
this
thing
can
kind
of
reach
in
and
play
with
it,
so
I'm
gonna
run
it
it's
going
to
start
tracing
it's
as
facing
it
started.
Flip
back
over
I've
got
the
app
already
open
on
another
tab.
Just
refresh
a
couple
times
just
generate
some
events
and
then
press
control,
C
trace
stops
down.
Here.
We've
got
a
new
file.
This
file
sample
web
app
Todd
and
there's
this
ID
net
perf
net
perf.
Is
this
new
event
pipe
file?
It's
a
lot
like
an
ETL
file
or
a
CTF
trace.
C
Zip
that
was
one
of
the
laws
are
DT
and
G,
where
the
the
there's
a
bunch
of
these
different
file
formats.
But
the
nice
thing
is
our
tools
to
analyze
these,
because
they're
built
on
the
stuff
per
few
users
can
just
read
all
of
them.
I
see
so
I've
got
this
file.
I
could
now
take
this
file
and
copy
it
over
to
a
Windows
machine
and
open
it
up
in
perfu
and
just
explore
it
as
though
I
had,
which.
A
C
C
Showing
some
command-line
tools
here,
but
the
core
of
this
is
some
libraries
right
right
is
api's.
We're
looking
at
ideas
like
howdy.
Can
you
build
a
general-purpose
kind
of
analysis
command
that
can
be
hosted
in
a
diff
bunch
of
different
kinds
of
UI
and
the
main
reason
we
want?
That
is
because
we
have
some
experience
of
how
the
runtime
works,
but
not
as
much
experience
with
what
people
actually
see
in
real
apps
right.
C
C
Talked
about
it
as
analyzers
at
runtime,
analyzers
run
it
yeah.
So
I've
got
this
new
command
line
here,
I'm
running
yet
another
project
out
of
this
repo
net
analyze
command
again,
this
will
just
be
done
at
space
analyzer,
my
future,
but-
and
it
may
not
be
analyzed.
Who
knows
what
will
some
verb
and
I've
just
passed
in
that
net
per
file,
so
all
I'm
doing
is
telling
it
to
load
that
up.
C
It's
gonna
load
that
up
and
I've
got
a
couple
commands
here
this
this
tool,
dotnet
analyze,
is,
does
two
purposes
right
now
you
couldn't
load
up
a
dump.
The
process
dump
which
I
have
not
do
not
have
at
this.
Okay-
and
you
can
do
things
like
you-
can
run,
dump
heap
dump
stack.
These
are
SOS
commands
that
run
purely
managed
without
the
need
for
a
debugger,
but
if
you
load
it
up
with
a
trace,
you
can
also
do
some
other
things.
So
I
can,
for
example,
just
say.
C
Requests
and
I'll
show
a
list
of
all
of
the
asp.net
requests
that
occurred.
While
the
trace
was
going
on,
I
can
say
logs
and
it
will
show
all
the
log
messages
and
a
bunch
of
data.
You
know
the
so
here's
the
logger
name,
here's
the
message:
if
they've
got
key
value
pairs,
the
key
value
pairs
are
printed
out.
There's
a
timestamp
I
can
also
filter
that.
So,
let's,
let's
just
look
at
the
ones
from
my
app.
C
A
A
To
be
focused
at
desktop
apps,
primarily
for
the
first
round,
but
you
know
the
ability
to
create
like
a
self-contained
EXCI,
you
can
just
deploy
and
it
runs
and
then
you've
got
your
app
yeah
I
mean
and
it'll
be
yeah,
it'll
be
trimmed
it'll
be
smaller
than
it
is
today,
but
I
still
don't
think
it
would
be
the
size
that
people
would
kind
of
be
burned
to
like
this
yeah
we'll
have
a
look
like
I
think
we'll
have
some
options,
everything.
Obviously
you
can
run
them
remotely
well.
C
And
so
there's
a
couple
options.
The
collection
logic
is
very
fairly
simple.
We
could
make
a
collector.
We
could
probably
like
we'll,
probably
look
at
packaging,
something
a
global
tool.
We
probably
packaged
as
a
global
tool,
but
they
provide
an
alternate
way
because
even
global
tools
require
the
SDK.
That's.
A
We
have
talked
about
in
the
past,
I
mean
a
lot
of.
This
is
just
there's
a
lot
of
work
right,
and
so
we
have
talked
about.
Wouldn't
it
be
nice
to
have
a
way
to
not
require
the
full
SDK.
Imagine
that
when
you
got
the
runtime
that
dotnet
XE
that
you
get
the
host
had
just
a
really
small
shim,
it
wasn't
the
full
SDK,
but
it
was
enough
to
install
a
tool
and
then
run
that
tool.
Yeah
right,
it's
like
the
assumption
is
you've
got
a
runtime.
B
A
If
it
didn't
have
the
compiler
and
all
the
other
stuff
in
it,
because
some
folks
are
worried
about
compilers
on
their
service
and
stuff,
which
is
fine,
we
have
no
plans
to
do
that.
Right
now
has
just
been
discussions,
but
you
can
imagine
a
future
where
that
might
happen.
I
think
for
now
it'll
be
that
we
can
safely
say
for
three:
oh,
you
probably
yeah,
but
between
two
two
and
three,
oh
and
for
three.
Oh
you'll
have
a
global
tool
available
to
you
and
maybe
they'll
wads
and
scripts,
or
something
that
you
can.
You
sort.
A
C
C
It
could
run
over
SSH,
okay,
so
the
last
thing,
though
I
wanted
to
show
is
I've
got
this
list
of
logs
next
to
each
one.
There's
this
little
hex
sort
of
ID
number.
This
is
this
is
console.
Ui
I
mean
we
can
make
these
clickable
links
in
another
UI.
But
if
I
just
take
one
of
these
I'll
take
this
one,
9e
I
can
go
event,
stack,
9e
and
now
I
get
this
dump
of
a
bunch
of
text.
But
this
is
the
stack
trace
from
the
bottom.
C
C
A
C
A
A
C
There's
another
file
here
next
to
the
app
so
here's
the
DLL,
the
depp's
etc.
There's
this
event
pipe
config
file.
If
I
just
take
a
look
at
that,
it
just
says:
hey
collect
these
providers
and
write
a
file
to
this
output
path
and
filter
to
just
this
process,
ID
and
so
dropping
this
file.
Next
to
the
app
starts
tracing
okay,.
A
B
A
A
A
Yeah,
but
it
kind
of
demonstrates,
you
know
the
mechanism
here
what's
happening
is
the
runtime
is
looking
for
this
file
on
boot-up.
If
the
file
is
not
present,
it
starts
a
background,
timer
and
says:
I.
Think
it's
every
10
seconds
it
says.
Is
that
file
there?
Yet
if
it's
not
okay,
well,
I'll
come
back
in
10
seconds
and
check
for
it.
If
it
is
there,
then
it
effectively
pings
it
every
second,
it's
my
understanding
right
now,
yeah
and
and
it
just
treats
it
as
an
input/output
channel,
it's
an
input
channel.
Basically,
it's
a
commanding
Channel.
A
B
A
A
That
will
wake
up
every
ten
seconds
to
check
for
this
file.
So
the
overhead
there
should
be
I'd.
Be
amazed
if
you
can
measure
it
honestly.
I'd
hope
that
you
can't
or
shouldn't
fact
what
you're
doing
and
then,
in
terms
of
data
volume,
there's
totally
up
to
what
you
capture.
It
does
nothing
until
you
issue
at
a
command,
and
it's
designed
to
be
like
egw,
where
you
don't
pay
any
overhead,
except
for
what
you
ask
it
to
do,
and.
C
I
would
expect
that
the
overhead
should
be
similar
to
what
you
get
when
perfu
is
turned
on,
etc,
right
and,
if
like
there
is
actually
an
option
which
I'm
in
the
wrong
folder.
That's
why
I
didn't
build,
there's
actually
one
of
the
options
that
the
tool
provides.
Is
this
circularbuffer
option
which
you
just
scan
up
there?
A
A
Then
and
then
and
there's
this
philosophy
is
kind
of
being
thought
about
through
the
design
of
event
that
the
event
counters,
which
we
haven't,
talked
about
yet
and
event
source
for
events
themselves
and
then
with
the
event
pipe.
The
idea
is
that
during
diagnosis
or
during
production,
you
might
want
to
be
capturing
just
a
very
low
number
by
default,
maybe
you're
just
capturing
some
core
counters,
which
aggregate
information
that's
collected
on
a
period.
A
So
it's
very
low
overhead
and
maybe
you've
got
the
system
to
only
listen
to
like
fairly
conditions
or
critical
events
like
you
detect
when
there's
thread
pull
starvation
or
you
detect
when
there's
unhandled
exceptions,
and
then
you
have
something
monitoring
those
events
through
a
vent
pipe
that
then
triggers
further
more
granular
tracing
or
takes
a
dump
when
something
goes
wrong
right.
So
that's.
B
A
Of
how
this
system
is
designed
is
that
you
have
the
lowest
overhead
by
design
in
production
to
to
find
things
that
have
gone
wrong
and
then
that
triggers
other
things
and
other
captures
as
a
result
of
doing
that,
or
it's
interactive
like
this,
you
can
just
have
the
process
live,
and
you
say:
yeah
I
want
to
do
like
a
five
second
trace,
I'm
going
to
catch
a
little
bit
of
information
to
put
me
in
the
right
direction.
Okay,
that
sent
me
over
here.
A
C
These
tools
that
we've
got
right
now,
the
dump
command
that
lets
you
capture,
process,
dump
right
now
and
the
collect
command
that
lets
you
capture
a
trace
right
now.
We
have
thoughts
of
putting
in
triggering
mechanism
yep
this
letting
them
demonize
that,
in
turn,
into
a
background
process
that
just
waits
for
some
condition
to
occur
and
then
starts
and
stops
tracing
yep
would.
B
C
B
C
A
A
monitor
app
service
for
your
web
apps
in
Azure.
Could
you
automatically
have
stuff
on
by
default
and
that
could
feed
into
the
portal
and
they
have
like
their
diagnosis
tools
that
will
detect.
They
have
like
health
detection
and
they
could
automatically
say.
Oh,
it's
not
their
core
app.
We're
gonna
automatically
enable
these
things
for
you
and
will
detect
if
they're,
simple
starvation
and
show
you
an
alert
without
you
having
to
do
anything
like
we
have
those
type
of
Indians
in
mind.
A
That's
all
like
observer
index
case
could
have
a
default
profile
that
enables
certain
things
they
you
know
you
could
choose.
That
is
all
the
things
that
we
want
to
enable,
and
this
very
core
feature
the
event
pipe
and
this
control
mechanism
enables
for
that.
Whether
the
controller
mechanism
remains
only
being
a
file
in
the
future.
We
remains
to
be
seen.
We
might
open
up
to
named
pipes
in
the
future.
A
Once
you're
up
in
a
pipe
gift
to
think
of
apples
and
security
and
a
lot
that's
not,
but
there
are
other
scenarios
that
might
benefit
from
having
different
control
mechanisms
and
we
intend
to
explore
those
as
necessary.
Nick's
asking
about
the
size
of
the
data
collected.
My
understanding
is
it's
a
binary
format,
so,
like
is
Jason
serialized
and.
C
He's
referencing
ETL
and
it's
very
similar
right,
so
I
wouldn't
expect
a
dramatic
change
from
what
detail
is
doing,
but
that's
something
I
think
we
should
explore
a
bit
more
because
because
ETL
files
are
big
yeah,
they
tend
to
be
quite
large.
We've
talked
about
ways
to
sort
of
compress
some
things
down,
also
ways
to
sort
of
stream
that
data
out
so
you're
not
having
so.
C
B
C
Would
never
run
a
memory.
You'd
just
run
out
of
events,
it
would
drop
the
mild
ones,
but
yeah
yeah,
it's
a
but
I,
think
you
know
right
now.
A
lot
of
has
been
about
getting
parity
with
etw
cross-platform,
but
I.
Think
part
of
that
is
so
that
we
have
somewhere
to
build
on
somewhere
to
move
forward
with
Michael's.
A
Asking
does
it
have
the
same
sort
of
cue
threshold
quirks
of
filesystemwatcher
house
to
be
aware
of
my
understanding.
Is
this
not
using
file
system?
What's
your
primitives
it
it's
a
timer
like
in
order
to
detect
the
the
commanding
file,
it's
just
looking
at
the
file
on
an
interval
yeah,
so
it
shouldn't
be.
It
shouldn't
have
any
issues
with
regards
like
dropping
events,
it's
just
a
cadence
yeah,
and
so
you
could
issue
it
commands
too
quickly.
So
you
could
like
issue
three
commands
within
a
second.
It
allowed.
A
You
get
the
last
one,
because
it's
only
checking
it
every
second
right.
You
have
to
think
about
that.
It's
not
an
API
call
right.
It
is
literally,
please
do
this
and
then
it'll
wake
up
in
the
next
interval
and
process
that
thing,
but
for
the
type
of
scenarios
we're
talking
about.
That's
intended
to
be
good
enough.
There's
also
someone
asks
about
in
process.
The
intent
is
the
intention
of
support
in
process
as
well
the
event
pipe
and.
C
A
A
B
C
Problem
you
run
into
there
is,
of
course,
let's
say:
you're
collecting
a
trace
and
it's
got
like
the
the
the
TPL
event
source,
which
is
tasks.
The
task
library
advise
lawyers.
Well,
if
you
do
anything
async
in
your
code,
that's
reading
that
event.
You're
gonna
trigger
more
events
too,
because
right
and
that
loop,
your
effects.
A
A
Example,
take
a
dump
of
yourself
or
you
may
want
to
set
a
feature
flag
to
turn
off
a
feature
when
you
detect
your
under
certain
load.
Okay,
there's
a
whole
bunch
of
things.
You
could
do
in
app
that
we
know
certain
customers
are
trying
to
do
today.
In
order
to
say,
oh
I've
detected
something
about
the
health
of
my
app
based
on
an
event
that
the
runtime
is
emitted.
I
want
to
go
and
do
something
as
a
result
of
that
in
my
application
itself,
rather
than
just
some
external
agent
yeah.
A
A
Did
paste
the
repo
it's
on
the
ASB
labs
repo
right
now,
I
think.
Eventually,
these
commands
will
move
into
probably
there's
a
doc
that
Diagnostics
repo
that
will
probably
they'll
end
up
moving
into.
We
also
have
been
trying
to
get
the
event
counter
scenario
to
work,
but
we've
had
a
bit
of
problem
with
that,
but
the
idea
is
that
there
will
be
a
command
yeah.
C
Didn't
talk
a
lot
about
event,
counters
right,
you
know
in
Windows
we
have
performance
counters
where
you
can
write
a
value
and
it
will
just
update
some
counter
and
you
can
watch
it
on
a
graph
change
over
time.
That's
the
the
lowest
granularity.
That's
the
the
high
level
view
that
you
kind
of
want
it's
a
start
in
dotnet
core
there's
something
called
an
event
counter.
Yes,
an
event
counters.
Basically,
they
plumb
the
same
kind
of
data
through
the
event
source
through
the
event
pipe
through
that
system
right.
C
C
Or
corvex
repo
I
think
if
you
create
event
counters,
you
can
collect
them
with
this
tool
right,
but
you
can't
get
a
live
view
because
this
tool
is
for
collection
and
then,
when
you
stop,
it
writes
the
files.
Obviously
you're
not
getting
a
live
view,
but
you
could
collect.
Stop
look
at
the
collect,
stop
look
at
them
right!
You
just
can't
get
the
live,
refreshing
view
right
so.
A
B
A
Of
people
do
they
just
want
to
look
at
the
per
counters
and
look
what's
happening
right
now.
Event.
Counters
are
the
way
to
do
that.
We
just
don't
have
the
for
and
and
yet,
but
this
is
something
that
we
want
to
through
a
vent
pipe,
so
cool
yeah.
We
are
an
hour
and
four
minutes
in
yeah
and
we've
got
through
the
demo.
So
hopefully
that
is
enough
to
give
folks
an
idea
of
what
we've
been
looking
at.
We
will
endeavour.
A
B
A
C
B
C
A
So
I
think
I
guess
maybe
we
should
commit
before
the
end
of
the
year.
We
should
maybe
not
you
you
won't
be
here.
No,
but
others
we
get
a
blog
post
out
or
something
or
maybe
just
update
the
readme
on
of
their
shows
the
walkthrough
of
how
to
do
your
first
session
like
get
it
going.
So
folks
can
get
going
so
well.
A
There,
maybe
is
email,
I,
don't
know
how
dramatic
it'll
be
okay
well,
I
mean
I
can
do
this,
which
is
always
there
fallback
right
now.
I
can't
reach
the
end
stream
button,
which
is
a
problem
with
this
design.
Now
we
have
to
do
something,
I
don't
know
it's
like.
We
add
that
we're
determined
to
fix
the
audio
first
yeah
you're
and
then
we'll
get
back
to
working
on
the
job.
We.
D
A
We
will
find
a
worthy
substitute,
a
worthy
replacement
for
the
dramatic
zoom.
Maybe
we
could
just
fade
the
lights
out.
The
control
box
is
over
there,
but
maybe
I
don't
get
them.
We
could
just
fade
the
lights
out
anyway,
thanks
everyone
for
watching
we
read
back
next
week.
I
don't
know
who's
on
next
week.
We
need
to
find
someone
to
come
up
with
something
to
talk
about
next
week.
You're
right,
okay,
everyone.