►
Description
Join members from the ASP.NET teams for our community standup covering great community contributions for ASP.NET, ASP.NET Core, and more.
Community links for this week: https://www.theurlist.com/aspnet-standup-2020-07-14
A
A
B
Right
now,
I've
been
working
on
server,
so
that's
still,
gastral
is
HTTP
server.
Things
like
that
I've
also
been
working
on
observability
of
the.net
platform.
All
up
so
that
includes
you
know.
Logging
metrics,
like
deep
Diagnostics
so
and
like
dotnet,
monitor,
actually
falls
under
that
purview
and
my
the
other
favorite
thing
is
just
service
to
service
communication.
Specifically
JIRA
PC
so
spread
a
little
thin,
but
that
means
more
chances
to
come
to
talk
to
you.
Jeff
awesome.
A
A
We
have
single
page
applications
with
both
client-side
and
server-side
routing,
so
with
client-side
routing,
as
you're,
navigating
through
you're,
actually
not
making
a
request
back
to
the
server
in
a
lot
of
cases,
you're
actually
just
changing
the
the
front-end
route
and
it's
actually
kind
of
handling
that
on
the
front
end.
The
problem
is,
if
you
bookmark
a
URL
or
if
you
do
a
full,
you
know
control
f5,
every
refresh,
then
you're
going
to
get
a
404
and
he's
running
into
that.
A
More
often
with
the
live
reload
server,
so
you
know
you
may
end
up
with
here
as
you're,
navigating
through
the
live
application
that
browsing
two
albums
works.
But
if
you
navigate
or
hard
refresh,
you
get
a
404.
So
he
talks
about
some
of
the
different
ways
of
handling
a
fallback,
and
you
know
one
way
is
to
use
endpoints
and
just
map
everything
back
to
index.html.
A
You
still.
You
know
you
still
run
into
you
issues
if
you,
if
you
have
a
missing
or
here
he's
going
to
test
HTML,
so
it
doesn't
handle
everything.
So
he
ends
up
with
a
all
back,
middleware
Handler,
and
so
it's
you
know:
I
love
the
whole
kind
of
middleware
handling
setup
and
how
you
can
handle
just
about
anything
with
it.
No
pun
intended
I
guess
so
here
he's
got
this
fallback,
middleware
Handler
and
that's
handling
that
mapping
so
stuff.
A
Speaking
of
middleware,
we
have
a
nice
long
post
going
through
the
asp
net
core
middleware
pipeline
from
Steve
Gordon,
and
so
this
starts.
You
know,
building
up
from
the
basics
explaining
you
know,
looking
at
a
basic
application
and
kind
of
talks,
building
up
from
the
fundamentals.
So
we're
talking
about
you
know,
we've
got
requests
delegates.
He
explains
what
middle
middleware
is
and
starts
with
the
basics
of
inline
middleware.
This
is
great.
You
know,
with
inline
middle,
where
you
can
just
return.
A
This
is
a
nice
one
to
kind
of
take
it
to
the
next
level
and
kind
of
understand
that
in
a
little
more
detail,
so
and
and
there's
a
huge
amount
of
power
in
the
you
know
in
the
whole
request
pipeline
and
middleware,
so
all
right,
jumping
over
to
a
nice
fun
one.
This
is
this
is
a
neat
one
from
John
skeet
there's
a
few
things
I
like
about
this
one.
Is
it's
just
crazy
he's
doing
this
video
he's
doing
MIDI
drums
with
blazer
and
he's
done
some
presentations
on
this?
A
What's
also
kind
of
fun
with
this?
Is
you
know
the
term
blog
goes
back
to
web
blog
and
the
initial
meaning
of
it
was.
It
was
just
a
it
was
a
blog
or
it
was
a
log
of
what
you
were
doing
right.
So
he
actually
writes
this
kind
of
in
a
log
format.
Here
he's
Friday
9:00
p.m.
here's
Saturday
morning
and
he's
going
through
and
just
talking
about
it.
So
you
can
do
it
quite
a
bit
now.
A
He
goes
through
and
talks
about
what
he's
building
out
he's
got
the
code
available
if
you've
got
MIDI
equipment
and
want
to
try
this
out.
But
it's
just
fun
to
see.
You
know
here
he's
going
through
and
initializing
MIDI
dating
through
what
the
MIDI
devices
he's
got
and
setting
different
kits
he's
got
a
MIDI
drum
kit,
so
I'm
just
kind
of
explaining
and
and
here
we
go
Sura
and
publishes
the
publishes
he
application
and
and
does
a
presentation
on
it
so
well.
This
is
pretty
cool.
A
So
if
you
do
have
a
suitable
roland
instrument,
you
can
try
it
out
yourself.
V
drum
explore
Gonski
UK.
So,
and
here
he
says
it's-
you
know
it's
it's
not
on
github
yet,
but
will
be
quite
soon,
alright,
so
changing
gears
a
bit
here
this.
This
is
a
very
light.
You
know
just
fun
series
on
game,
dev,
2d,
game
dev
in
blazer
from
dahveed-
and
here
this
is
part
three.
These
are
just
little
bite-sized
chunks.
So
here
he's
going
through.
A
This
is
the
third
one
in
a
series
and
he's
just
doing
simple
things
like
envis
and
sprites.
So
each
of
these
posts
you
can
read
through
in
just
a
few
minutes-
and
you
know
here's
just
talking
about
things
like
initializing
canvas
and,
and
you
know,
using
sprite
management
and
stuff,
so
there's
some
cool
stuff
and
as
he
calls
out
in
the
first
one
here
he
originally
you
know
decades
ago
got
into
programming
because
of
game
development.
A
I
know
that
that
was
some
of
my
first
early
programming
stuff
was,
you
know,
writing
silly
little
games
and
basic,
and
it's
just
it
is
a
fun
way
to
get
into
and
learn
new
programming
stuff.
So
well,
alright!
Now
we
get
to
the
big
one.
This
is
the
okay,
so
here
actually
let
me
there
is
a
performance
improvements
in
dotnet
and
it's
actually
such
a
big
post
that
I
have
three
bookmarks
on
it.
So
there's
the
I'll
jump
up
to
the
top,
but
this
is
Steven.
A
Taub
he's
been
doing
these
yearly
and
he
just
goes
through
for
the
major
releases
and
talks
about
all
the
benchmarks
and
all
the
performance
improvements.
It's
fun,
because
these
includes
the
information
on
how
to
actually
run
these
yourself
and
how
to
test
these
benchmarks
out
and
what
I
love
about
dotnet.
A
What
he
shows
in
here
and
just
in
general,
what
I
love
about
dotnet
performance
improvements?
Is
they
ripple
all
through
the
stack
so
when
something
improves
in
text
processing
that
affects
my
you
know,
estriol
and
that
affects
my
Jason
performance,
etc.
So
so
here's
some
things
that
that
I
kind
of
wanted
to
call
out
to
four
asp
net
devs,
so
one
is
text,
processing
and
sera
feel
free
to
jump
in.
If
there's
anything
you
see
that's
interesting
here.
A
So
here
there's
just
a
lot
of
neat
stuff
earlier
on
and
throughout
this
post,
there's
a
lot
that
goes
into
explaining
things
like
using
more
hardware,
intrinsics
and
just
continuing
to
like
say
hey:
can
we
can
we
jump
out
of
this
code?
Do
we
need
to
you
know
for
checking
bounds
three
times
we
can
just
do
it
once
etc.
He
does
in
this
area,
talks
about
the
utf-8
formatter
and
also
the
Latin
encoding.
A
A
In
a
lot
of
cases
to
there's
things
like
you'll
see
also
called
out
in
here,
you
know
vectorization
and
a
lot
of
the
time
there's
a
big
difference
in
allocation
as
well,
which
is
really
cool,
regular
expressions
again,
this
is
something
where
you
know:
if
you're
figuring
out
is
something
an
email
address,
is
something
a
URL.
Regular
expression
performance
is
really
important,
so
text
processing,
pretty
cool
networking,
of
course,
huge
right,
and
so
this
is.
A
This
is
neat
looking
at
some
of
the
things
and
again
like
look
at
this
allocation,
one-fifth
as
much
in
the
constructor
for
URI.
You
know
just
continual
like,
of
course,
parsing
out
path
and
query
in
a
URI
is
something
in
an
ASP
NetApp
and
then
again
in
service
code
that
you're
going
to
be
doing
all
the
time,
and
so
so
it's
cool
to
see.
You
know
things
like
that.
A
Just
continue
to
get
better
and
again
this
is
you:
don't
have
to
do
anything
to
use
this
stuff,
you
get
on
the
newest
got
neck
or
five,
and
you
just
get
this
stuff
for
free.
So
that's
neat
one
other
one
I
wanted
to
point
out
is
Jason,
so
System
text
jason
has
a
bunch
of
cool
stuff,
including
improvements
like,
for
instance,
for
the
jason
serializer.
So
again,
just
like
this
is
just
fun.
Man
look
at
going
from.
You
know,
24k
down
to
152
bytes,
so
I'd
I
just
I
love
geeking
out
over
this.
A
This
is
a
long
read
this
is
you
know,
I
think
a
lot
of
this
stuff
is
going
to
be
over
a
lot
of
you're,
not
gonna,
know
all
this
stuff,
but
it's
just
fun.
So
I
I
love
reading
through
these
and
then
again,
there's
a
fun
art
way
down
at
the
end
that
he
calls
peanut
butter
and
the
idea
here
is
it's
just
a
stuff:
that's
spread
all
across
dotnet
in
general,
so
things
like
aster,
math,
faster
assembly,
loading,
faster
crypto.
A
A
A
B
B
So
yeah,
just
you
know,
talking
about
net
monitor
we
actually
ship
it
in
two
form
factors,
so
it
ships
as
a
dotnet
global
tool.
So
you
can
use
it
locally.
You
can
use
it
on
a
remote
machine.
You
can
use
it
anywhere
where
you
traditionally
use
that
net,
but
the
other
fun
thing
that
we've
done
is
we've
also
packaged
it
up
as
a
container
image.
B
A
B
Do
you
mean
by
side
card?
Oh
okay,
so
there's
a
pattern
so
I'll
use
kubernetes
because
it
seems
to
be
the
orchestrator
everyone
uses.
There's
a
saudi.
The
unit
of
deployment
that
you
should
think
about
is
a
pod
right
and
a
part
can
be
comprised
of
multiple
containers,
but
there's
some
guarantees.
The
orchestrator
gives
you
like:
hey
the
like.
All
containers
in
the
part
want
is
share
the
same
network
namespace.
B
They
will
be
co-located
on
the
same
physical
nord,
so
there
are
a
couple
of
guarantees.
So
a
common
pattern
is
for
concerns
that
are
relevant
to
your
application,
but
not
necessarily
solved
by
your
application
code.
Like
you
know,
diagnostics,
logging,
those
are
common
patterns
or
service
mesh
is
another
one,
but
what
you
do
is
you
like
here?
I
will
deploy
another
container
alongside
my
application
container
in
the
same
pod
right
and
those
containers
are
usually
referred
to
as
sidecar
containers.
B
Okay.
So
in
our
case,
what
we're
trying
to
do
is
we
want
to
make
it
easier
to
get
access
to
diagnostic
artifacts
right.
We
want
easier
access
to
metrics
to
logs,
to
you
know,
process
dumps
to
traces.
So,
let's
like
I'll
think,
like
you
know,
traces
is
an
example.
You
want
the
ability
to
collect
the
trace
from
your
application,
but
it's
not
necessarily
your
applications
concerned
right.
So
sidecar
is
a
great
pattern.
B
You
deploy
something
alongside
your
application
and
it
exposes
some
API
surface
that
when
you
want
to
collect
a
trace,
you
talk
directly
to
the
sidecar.
So
there's
like
the
separation
of
concerns
and
when
you
write
code
you
don't
have
to
be
aware
or
think
of
hey.
How
can
I
make
my
application
aware
so
that
it
can
be
traced?
Okay,
all
right,
so
what
I'm
gonna
do
is
I'm.
Actually,
let
me
start
sharing
my
screen
and
then
let
me
know
when
you
can
see
it.
B
Yeah
I
see
okay,
awesome.
So
what
I'm
gonna
do
is
first
time
I've
actually
acquired
the
tool
locally,
so
I
will
show
you
that
it
can
be
used
locally,
and
then
we
look
at
the
in
cluster
scenario
as
well
right.
So
just
just
so,
we
can
show
people
right
now.
This
is
still
on
our
like
DNC
and
package
feed.
So
this
isn't
quite
yet
pushed
in
you
get
our
org,
but
the
link
is
in
the
blog
post.
So
if
you
want
to
go
get
started,
you
can
do
this.
B
B
Up:
okay:
let's
do
this
so
I
have
darknet,
monitor
and
install
locally.
You
can
see
that
it
has
one
verb
that
it
ships
with
called
collect.
So
if
I
go
ahead
and
do
black
nerd
monitor
collect,
it
actually
starts
up
a
web
service.
So
now
this
is
interesting,
so
let's
actually
go
over
to
the
endpoint
exposed
by
this
right
and
see
what's
actually
exposed.
B
So
if
I
go
over
here,
you'll
see
nothing
is
exposed
to
the
route.
That's
okay,
the
404
is
expected,
but
there
all
of
endpoints
and
first,
let's
look
through
what
is
what
it
exposes.
So
obviously
for
any
of
these
types
of
operations.
First,
we
need
to
know
what
process
we
want
to
target
right,
so
it
does
expose
a
processes
endpoint
and
you
can
see
right
now.
It
shows
me
just
like
the
pids,
so
these
are
like
when
I
make
an
operation
like
say,
collect
a
process.
Dump
I
would
want
to
specify
what
paid.
B
It
is
a
little
smart
in
that.
If
there
is
only
one
target
process
detected,
then
you
don't
need
to
specify
what
bid
and
that
turns
out
to
be
super
useful
in
the
context
of
a
like
a
part,
because
you
usually
only
have
one
instance
of
an
application
container.
So
I'll
show
that
in
a
bit-
but
here
you
can
see
I
have
a
couple.
B
B
B
B
Diagnostic
tools,
work,
not
only
with
you,
know,
applications
that
you
write,
but
anything
that
uses
Darden
ed
core.
So,
in
our
case
like
on
my
in
my
computer,
I'm
running
you
get
package
Explorer
and
you
can
see
that
it's
also
a
dotnet
core
app,
so
I'm
able
to
detect
it.
So
it
was
also
in
this
list
of
processes
right
so
now
using
some
of
the
endpoints
included.
So
if
I
go
to
slash,
tell
slash
pay
it
right,
so
this
is
new,
get
back
Explorer!
You
actually
look
down
here.
B
The
other
thing
I
can
do
is
so
I
can
just
hop
back
over
to
the
blog
post
and
show
you
what
are
the
endpoints
that
we're
going
to
be
looking
at.
So
these
are
the
end
points
we
have
dump
that
allows
you
to
collect
a
process
dump
each
of
these
have
a
little
more
options
on
them
like
you
can
specify
you
know
the
the
type
of
dump
or
in
the
case
of
traces
which
provide
us,
but
we
have
dump,
which
is
a
full
process.
Dump
we
have
this
diagnostic
artifact
called
a
GC
dump.
B
It's
something
I've
blogged
about
before
it's
basically
aa
by
instrumenting,
the
GC
like
when
a
GC
operation
occurs.
We
actually
emit
events
and
through
those
events,
we
can
construct
an
object
graph
of
all
objects
on
the
heap.
So
you
can't
necessarily
see
like
field
values,
but
you
can
see
the
graph
of
all
objects.
So
this
is
a
lightweight
artifact
like
a
GC
dump
like
with
artifact,
then
it
gives
you
visibility
on
to
what's
going
on
in
the
heap
without
the
expense
of
you
know
a
full
process
down.
B
So
it's
a
much
smaller
artifact
and
it's
also
a
more
portable
artifact.
It
isn't
tied
to
the
OS
and
there
aren't
restrictions
on
how
you
can
consume
it.
So
the
endpoints
we
expose
are
the
dump.
End
point
is
GC
dump
we
have
trace
and
when
you
don't
specify
anything,
the
trace
includes
a
CPU
profiler,
so
you
get
manage
stacks.
You
also
get
events
for
HTTP
requests
start
and
end,
but
you
also
have
the
ability
to
enable
any
event
source
provider,
and
then
we
also
have
an
endpoint
that
allows
you
to
stream
back
logs.
B
So
your
you
know,
like
Microsoft
extensions,
ilogger
logs,
the
ones
that
you're
used
to
in
your
web
application
can
be
streamed
out
and
we
have
a
lost
endpoint
that
allows
you
to
see
a
snapshot
of
the
metrics,
so
we'll
go
over
each
of
them,
but
what
I
wanted
to
showcase
now
is
this
is
applicable
both
so
I,
like
what
I
showed
you
right
now,
as
I
was
using
it
locally
to
collect
a
process
dump
I.
Could
even
you
do
it
on
a
remote
machine.
Let's
say
it
was
a
secure.
B
Network
I
could
run
dartnet,
monitor
on
a
remote
machine
and
then
use
it
to
collect
like
a
diagnostic
artifacts
from
that
machine.
If
you
want
to
do
anything
more
than
that,
like
the
onus
is
on
you
to
secure
it,
so
we're
not
we're
not
trying
to
solve
that
just
yet,
but
we
will
be
interested
to
see
how
people
use
it
and
what
kinds
of
problems
they
solve
and
that's
actually
a
lot
of
the
feedback.
We're
trying
to
solicit
right
now
as
we're
looking
for
future
investments.
Okay,.
A
Okay,
I
have
a
question
that
I'm
not
exactly
sure
to
ask.
Hopefully
you'll
get
the
idea
and
and
figure
it
out
from
what
I'm
saying
well
at
what
level
does
dot
dot
net
monitor
hook
into
things
so
like
if
I've
got
multiple
things
you
showed
like
NuGet
package
Explorer,
which
is
a
desktop
app
right.
You've
got
multiple
different
processes,
instrumented
or
is
everything
kind
of
registering
with
that
or
hey?
So
that's.
B
So
what
we've
been
doing,
starting
from
I,
want
to
say
dotnet
cord
to
one?
Is
we
introduced
this
abstraction?
So
we
already
had
this
abstraction
called
event
source
in
the
runtime
right
and
event.
Source
events
were
egressed
in
the
case
of
like
when
we
were
Windows
only
were
egressed
etw
when
dotnet
core.
When
cross-platform
we
started
egressing
these
two
LT
T
and
G
as
well.
B
So
these
are
like
user
defined
trace
points,
but
the
the
goal
was
always
because
we
had
an
abstraction
right
like
when
you
emit
events
or
events
you're,
not
tied
to
Windows
or
you
not
die
tail
to
the
engine.
So
having
that
attraction,
let
us
expand
different
collection
mechanisms,
so
what
we've
done
in
recent
releases
is
the
dotnet
core.
Runtime
actually
exposes
a
diagnostic
server
right,
and
this
diagnostic
server
listens
on
a
platform
native
transport.
B
So
in
the
case
of
Windows
it
would
be
a
named
pipe
and
in
the
case
of
like
Mac
or
Linux,
this
is
a
UNIX
domain
socket
and
now,
as
the
name
diagnostic
service
suggests,
it
is
a
server.
So
it
speaks
the
request
response
protocol.
So
that
is
something
I
can
actually
hop
over
to
the
dotnet
Diagnostics
repo
and
that
actual
IPC
protocol
is
documented.
Here
it
is.
B
A
I
guess
you
know
part
of
the
thing
with
this
is
now
with
dot
NetBeans
so
like
you
could
have
multiple
different
versions
of
it
running
it's
so
kind
of
distributed
and
broken
apart
that
you
know,
I
could
have
multiple
different,
like
I
could
have
things
running
in
containers
and
all
that,
so
basically,
it's
I
can
create.
I
could
potentially
have
more
than
one
of
these
diagnostic
servers
running
on
a
machine
and
they're,
just
all
registering
with
whichever
ones
they
would
want
to.
B
Battle
phrase,
but
I
would
have
hopefully
answered
your
question:
every
darknet,
core
application,
I'm
gonna,
say
three
one
and
above
cuz
there
are
some
like
variations.
Every
Darden
and
core
application.
3-1
and
above
always,
has
a
diagnostic
server.
It's
listening
to
that
it.
So
any
dartnet
process
has
the
server
and
then
your
diagnostic
tool.
So
in
this
case
that
would
be
your
client
each
of
your
class.
Any
client
can
connect
any
dotnet
server
on
the
process,
provided
you
have
permissions
and
then
request
at
the
runtime
egress
information.
Oh
okay,.
A
B
Owner
so
so,
if
I
go
back
to,
let
me
answer
in
the
context
of
dotnet
monitor
and
then
that's
more
broadly
applicable
to
just
uses
of
the
diagnostic
server.
There
is
no
observable
overhead
when
you
are
not
asking
the
runtime
to
egress
information,
okay,
alright,
so
if
it's
just
sitting
there
the
server
there
is
no
overhead.
Now
in
our
so
you
know
we
care
about
per
father
and
we're
on
tank
and
power
bench
locally.
So
in
our
infrastructure
and
I
think
you
know,
Sebastian's
government
talked
about
this
on
the
show
as
well.
B
We
actually
collect
metrics
the
mechanism
that
we
used
to
collect
metrics
even
in
our
birth
tests
is
the
same
mechanism.
We
actually
talked
to
the
Diagnostics,
oven
the
runtime
and
ask
it
to
egress
these
events,
so
for
what
we've
recorded
is
for
something
low
overhead,
like
metrics,
there's
no
visible
performance
impact.
Now.
Obviously,
if
you
go
to
the
point
where
you
are
say,
CPU
sampling,
then
there's
a
huge
performance
impact,
because
what
we
have
to
do
is
you
know
the
I
think
the
default
frequency
is
up.
B
We
collect
us
CPU
sample
every
one
millisecond,
so
every
one
millisecond,
we
have
to
pause
all
your
threads
synchronize
them
then
walk
each
stack
and
write
an
event
and
then
let
the
you
know
execution
continue
so
based
on
the
kind
of
diagnostic
operation
you
perform,
there
will
be
an
overhead,
but
the
goal
that
we
want
to,
like
our
you
know,
desired
state,
is
when
you're
not
actively
addressing
information.
There's
no
there's
no
observable
impact.
Okay,.
A
B
Yes,
like
any
time
you
you
know
you're
talking
to
the
runtime,
there
are
some
considerations,
Saudi
I
think
I
think
I
mentioned
before.
Is
we
listen
on
a
platform
native
transport,
so
the
the
nice
thing
about
both
windows,
name
pipes
and
UNIX
domain
sockets?
Is
they
use
file,
descriptors
or
I?
Guess
in
the
case
in
Windows
to
I
guess
file
descriptors?
That
also
means
you
can
Akal
them
and
restrict
access
like
you
could
to
files.
So
it
really
comes
down
to
if
I
have
permissions
to
access
your
application
and
execute
your
application.
B
Only
then
can
I
connect
the
diagnostic
server.
So
we
have
a
couple
more
we're
like
looking
at
certain
patterns
like
in.net,
five
we're
actually
adding
this
feature
or
we've
just
added
it.
Well,
the
runtime
can
not
only
act
as
the
server
it
can
act
as
a
client,
so
your
diagnostic
tool
could
be
the
server
and
your
application
when
it
starts
up,
will
connect
out
to
your
diagnostic
tool
and
send
event.
B
So
it's
like
we
flip
the
polarity
right
and
that's
useful
for
scenarios
like
startup
tracing,
because
in
the
current
pattern
it's
hard
to
do
startup
tracing.
So
when
we
add
new
functionality,
where
none
of
that
is
opted
in
and
we're
getting
it
behind
knobs,
so
it's
a
very
like
explicit
gesture
you
have
to
make,
but
it's
it's
a
great
question
and
you
have
to
be
cognizant
of
that
and,
like
you
know,
make
sure
you
make
a
determination
based
on
your
use
case.
B
One
thing
that
I
will
talk
to
in
the
case
of
dotnet,
monitor,
actually
I
think
this
is
a
perfect
segue.
If
I
go
back
to
the
endpoints
exposed
by
dotnet
monitor
eight
T,
what
we
have
done
when
we
did
a
security
evaluation
and
we
did
threat
modeling,
we
said
hit
all
of
these
endpoints,
so
starting
from
dumps,
GC
dumps
traces
and
logs
they
actually
egress.
They
can
egress
information
that
could
be
sensitive
to
your
application.
B
So
what
we're
gonna
do
is
the
dotnet
Monitor
process
actually
binds
to
two
different
ports,
so
it
has
the
it
has
a
port
that
only
exposes
the
matrix
endpoint.
Why?
Because
we
made
the
determination
that
metrics
are
safe
to
expose
and
in
fact
that's
a
common
pattern
right
people
use
tools
like
Prometheus
to
scrape
metrics
that
are
exposed
to
an
endpoint
so
for
the
rest
of
these
operations
very
much
so
they
are.
B
They
expose
sensitive
data
and
should
not
be
like
exposed,
obviously
to
the
Internet,
but
even
in
the
context
of
say
in
your
cluster,
you
don't
know.
If
you
are
I
mean
it
depends,
if
your
other,
if
it's
a
hostile,
multi-tenant
scenario
or
not,
but
even
then
the
recommendation
would
be
do
not
expose
these
endpoints
to
other
tenants.
Okay,.
B
A
C
B
No,
no,
these
are
good
questions.
I
actually
liked
the
flow
because
they
a
you,
know
natural
progression,
so
they're
they're,
actually
two
things
that
I
want
to
like
tease
apart,
then
is
the
diagnostic
server
in
the
runtime,
which
is
the
you
know,
the
technology
underpinnings
of
how
dotnet
monitor
works
and
there's
dotnet
monitor
itself
right.
So
let
me
answer
the
question
in
the
context
of
the
diagnostic
server.
First,
the
diagnostic
server
uses
the
same
occurs
as
your
application
does.
B
So
if
I
was
to
go
into
details
in
in
the
case
of
Linux
and
Mac
OS,
we
create
a
UNIX
domain,
socket
in
the
temp
directory.
Now
the
permissions
and
I
think
in
the
case
of
Mac
OS,
we
actually
sell
apples
on
that
directly.
The
common
pattern
for
the
temp
directory
is
anyone
can
create
a
file
in
there
and
everyone
else
can
see
it
but
can't
modify
it.
B
C
B
B
Okay,
in
the
case
of
windows,
the
name
socket.
Sorry,
all
all
name
pipes
are
in
the
year.
There
is
no
like
directory
hierarchy,
so
all
name
pipes
are
created
in
the
root
of
the
like
the
name
pipe
file
system,
and
then
we
just
wait
for
it
there,
okay,
but
like
if
I
am
like,
if
I
am
like
user
foo
who's
who
has
who's
running
the
application,
I
can't
talk
to
the
pipe
unless
I
have
permissions
for
users
foo.
B
Okay,
now
in
the
context
of
dotnet
monitor,
because
we
are
actually
you
know
so
as
to
speak,
creating
an
HTTP
proxy
for
the
diagnostic
server
right
now,
quite
we've
actually
made
convenience
methods,
but
because
it's
an
HTTP
endpoint
anyone
who
can
access
the
HTTP
endpoint
can
now
access
these
accesses
diagnostic
data.
So
you
have
to
be
careful
on
how
you
expose
it.
So
I
will
show
you
the
the
kubernetes
use
case
and
they'll
kind
of
give
you
an
example.
B
It
also
leads
to
one
other
thing
that
we're,
actually
you
know
trying
to
get
feedback
on,
so
everything
I'm
showing
you
about
dotnet
monitor
today,
is
what
is
is
useful
for
ad
hoc
analysis
right.
This
is
at
the
point
where
you've
ascertained,
there's
a
problem
and
you're
like
hey
I
need
a
diagnostic
tool.
I
could
use
to
collect
data
when
I
already
know
there's
a
problem.
So
that's
what
I
call
manual
triggering
we
understand
the
manual
triggering
is
only
one
of
like
a
multitude
of
use
cases.
So
obviously
there
could
be
something
in
the
future.
A
B
What
I'm
going
to
do
is
I'm
going
to
real
quickly.
I'll
show
you
this
tab
so,
like
I
said,
doctor
monitor
ships
both
as
a
global
tool
as
well
as
an
image,
so
you
can
see
I'm
on
docker
hub
and
I'm
on
the
dotnet.
It's
the
nightly
images
so,
like
I,
said
we're
still
in
preview,
so
this
right
now
ships
only
as
a
nightly
image.
But
you
know
as
this
project
matures
we
will
ship
it
as
under
MCI
or
Microsoft.
B
Slash,
dot,
net,
slash
monitor
so
right
now
we
have
one
image
and
it
has
the
tag
of
Fievel.
So
you
would
do
darker
pull
this.
If
you
wanted
to
use
it
so
I
will
just
quickly
reference
the
blog
post.
There
is
instructions
on
how
to
run
locally
in
darker,
but
I'm
actually
gonna
skip
this
and
head
over
to
the
kubernetes
part,
because
that's
the
interesting
thing.
B
So
let
me
go
over
to
my
kubernetes
deployment
file.
So
nothing
here
should
be
too
interesting.
But
let
me
just
walk
through
what
I'm
doing
here
and
there
are
certain
parts:
I'll
come
back,
so
I
have
a
deployment
and
this
deployment,
if
I
go
under
the
containers,
is
comprised
of
two
containers.
One
is
my
server
container
and
the
other
is
my
sidecar
container
alright.
So
this
is
what
I
meant
by
sidecars.
These
are
new
containers
in
the
same
pod.
Okay
I
serve
a
container
in
this
case.
B
B
Hopes
thanks
thanks
for
the
timely
reminders.
Ok,
so
I
have
my
server
container
and
my
starter
container,
so
my
server
container
is
a
web
application
and
it's
listening
on
port
80
right,
nothing
out
of
the
ordinary
there
and
then
I
have
my
sidecar
container
and
it's
listening
on.
So
it's
exposing
port
5
to
5
to
3
to
5
right.
If
you
actually
look
look
closely
at
the
next
line,
you
can
see
that
there's
a
URL
set
X
and
a
matrix
URLs.
So
this
is
what
I
spoke
about.
B
So
the
only
port
that
we
are
exposing
right
now
is
the
matrix
URL.
It
also
has
another
URL
for
deep
Diagnostics
artifacts
that
we
aren't
exposing.
Yet
so
I'll
show
you
how
to
get
to
that,
and
the
only
other
thing
about
configuration
right
now
is
I've
created
this.
You
called
the
Diagnostics
volume
yeah.
It's
not
fortunate
that
when
I
mouse
over
it
gives
me
tooltip
text
which
I
don't
want
is
so
I
mounted
the
Diagnostics
volume
in
the
temp
directory,
both
in
my
server
container,
as
well
as
my
sidecar
container
right.
B
B
B
Let's
go
over
here
into
key
again
I'm
just
waiting.
This
is
just
kubernetes
get
boards
with
the
wait.
Oh,
it
looks
like
it
already
terminated
and
finished
running
so
cool.
So
I
have
my
parts
running
right
now,
given
that
this
is
a
new
cluster.
I
haven't
quite
set
up
an
ingress
resource,
yet
so
I'm
gonna
do
a
neat
little
trick.
What
I'm
going
to
say,
okay,
poured
forward
I'll,
do
/name
of
the
part
and
I'll
say,
poured
7,000
maps
to
port
80
inside
the
container
inside
that
part.
This
should
normally
be
required.
B
B
Localhost
was
at
7,000,
I.
Think,
okay,
there
you
go
so
this
is
my
application
running
right,
nothing,
fancy!
This
is
a
regular
answer
in
an
application
you
can
see.
You
know,
there's
some.
It's
dotnet
over
three
one,
five
running
on
like
Linux
kernel
version,
4.1,
five
I
didn't
just
some
basic
information
now
the
other
thing
I'm
gonna
do
is
I'm
actually
going
to
forward
traffic
to
another
port.
So
let
me
do.
B
B
So
this
sport
wasn't
actually
exposed
right.
So,
like
think
of
this
analogy
on
it,
I'm
in
right
now,
I'm
like
hey
my
application,
that
I
just
showed
you
right
this
one
there's
something
wrong
with
it:
I
want
to
go,
collect
a
process
dump.
How
do
I
do
that
at
this
point.
For
me
to
be
able
to
run
this
command,
I
am
a
cluster
administrator
that
I
can
just
randomly
forward
traffic
into
any
port.
B
So
this
already
is
a
huge
like
security
requirement
right,
but
now
that
I've
done
this,
if
I
go
back
here
and
let
me
hit
localhost
7001
and
let
me
hit
the
processes
endpoint.
So
you
see
I
only
see
one
process
with
build.
One
running
right
and
the
remember
thing
I
told
you
about
this
convenience
method.
When
there's
only
one
process,
ID
I
don't
have
to
specify
any
promise.
Now,
if
I
go
ahead
and
hit
slash,
dump
like
it's
gonna
take
a
second,
because
it's
a
streaming
endpoint
but
like
let
this
just
sink.
B
A
B
A
A
B
B
So
don't
don't
like
unless
you're
gonna
do
some
sort
of
like,
like
TLS
mutual
art
and
secure
that
endpoint,
please
never
expose
the
URL.
You
can
expose
the
metric
URL
and
also
that
in
a
second,
so
I
was
able
to
collect
the
dump.
I'll
show
a
couple
more
things.
Let
me
show
you
the
3s
endpoint
right.
So
this
is
the
one
I
told
you
enables
the
CPU
profiler
and
collect
traces.
So
it's
currently
a
streaming
thing.
So
I'm
gonna
go
make
some
request
side.
It
makes
them
requires
to
put
some
synthetic
traffic
into
this.
B
C
B
This
netlist
now
the
cool
thing
about
this
again
is
you
see
actually
shows
that
this
is
studio
icon.
If
I
go
ahead
and
open
this
again,
let
the
sink
in
I
just
collected
a
CPU
trace
from
inside
a
cluster.
That's
you
know,
running
Linux
and
I'm
able
to
open
this
in
Visual
Studio
or
should
did
not
realize
that
just
updated
visuals
yeah.
So
we
can
let
this
run
for
a
second
and
I
will
show
you
the
other
one
and
I'll
get
back
to
this
when
Visual
Studio
is
done,
one.
A
B
There
was
something
I
really
wished,
I
could
show,
but
I
couldn't
just
yet
so
these
are.
This
dump
file
is
the
Linux
elf
dump.
So
we
have
a
tool
called
dotnet
dump,
that's
the
command-line
tool
that
allows
you
collect
a
dump.
It
also
has
a
hosted
ripple.
So
if
you
do
dotnet
dump
analyze
and
pointed
at
or
dumped
it
can
analyze,
the
cord
am
now
a
limitation
that
we
had
was
because
of
the
nature
of
how
the
runtime
and
the
DAC
is
built.
B
You
could
only
analyze
a
dump
file
on
a
machine
that
has
the
same
like
same
DAC,
so
it
basically
has
to
be
the
same
or
OS
business
architecture
and
Lib
C
version.
So
I
actually
mentioned
this
in
the
blog
post,
which
is
sorry
here.
You
can
run
or
docker
container,
so
you
can
docker
run
and
then
analyze
it
using
dotnet
dump,
but
the
other
thing
that
I'm
super
excited
to
share
and
is
that
we
have
recently
so
we
have
this
component
in
the
in
the
runtime
called
the
DAC.
That's
the
direction.
B
B
Coming
really
soon,
okay,
but
for
now
I
would
say
the
easiest
way
to
do
it
is
you
know,
just
dock
it
on
and
use
something
that
has
the
same
base
image
as
the
platform
it
was
collected
on
and
then
you
can
analyze.
So
in
the
context
of
the
first
dump
I
collected,
remember
that
was
just
dumped
on
Windows
off,
like
nougat
package
manager.
That
can
be
analyzed
right
away
because
it's
already
the
same
OS
architecture,
business,
okay,.
B
So,
oh
yeah,
sorry,
that's
what
I
almost
forgot!
Okay!
So
here
you
can
see
I
have
you
know
this?
Is
my
sampled
CPU
stacks,
so
I'm
able
to
see
things
like
you
know
already
shows
me
the
hot
path.
I,
don't
think
there
was
anything
interesting
so
as
to
show,
and
it
also
has
this
events
viewer,
so
I
will
just
scroll
down
till
I
see
a
couple
of
interesting
one's
right.
So
we
have.
These
are
all
sample.
Profilers
I
wanted
to
show
the
metrics.
How
do
I
do
this?
B
Okay,
there
you
go.
Let
me
do
this
so
I
want
to
say
we
collect
a
couple
more
events,
so
this
also
has
you
see
the
value
of
these
event?
Counters
excerpt
durations
there,
so
we
are
working
on
some
functionality
in
visual
studio.
Well,
like
all
the
CPU
samples
are
interesting.
What
would
be
even
cooler
is,
you
could
say
hey.
You
know,
there's
a
graph
like
just
plot
my
CPU
usage
and
then
I
only
want
to
see,
like
you
know,
like
I,
want
to
do
a
time,
slice
and
stuff
based
on
the
event
value.
B
So
that's
some
functionality
that
we're
about
to
add.
But
the
good
thing
is
you
know
the
art
tool
and
digital
studio
are
already
on
the
same
page,
so
we're
already
egressing
that
correct
information.
Ok,
so
there's
also
the
GC
dump,
and
let
me
skip
that
in
the
interest
of
time
and
let
me
show
you
the
other
fun
one.
Let
me
dial
this
side-by-side,
so
you
can
actually
see
it
and
so
I
have
my
here
and
then
remember.
I
said
we
have
a
logs
endpoint
same.
You
know
the
log
logs
that
you're
used
to
now.
A
B
This
is
streaming,
you
can
see
it's
just
continuing
stream.
The
other
thing
is,
if
you
look
at
the
logs
to
see
that
these
are
actually
like
debug
logs
I'm,
seeing
in
here
so
the
verbosity
of
logs
I,
forget
that
query
parameter,
I,
think
it's
level,
but
I
don't
want
anyone
to
quote
me
on
it.
I
can
you
know
clarify
later
you
can
specify
a
verbosity,
that's
higher
than
say
what
you
did
in
your
app
setting
star
JSON
file.
A
B
This
only
so
the
query
string
parameter
only
impacts
the
log
level
that
you're
seeing
here
in
the
streaming
response.
Okay,
if
you
had
like
an
app
settings
or
JSON
file,
that
was
like
say,
writing
the
console
or
writing
to
some
other
log
provider
that
log
level
is
not
affected.
Okay,
so
that's
what
you
want
right.
You
want
you're
always
on
pipelines
to
continue
to
do
what
they
always
did,
and
your
ad
hoc
analysis
give
you
the
ability
to
turn
it
up.
Okay
and
then
the
last
endpoint
I
wanted
to
show
was
the
metrics
endpoint
right.
B
So
if
this
looks
familiar
or
even
if
it
doesn't,
this
is
actually
metrics
exposed
in
the
Prometheus
style,
the
Prometheus
exposition
format.
So
we
have
the
metric
name.
We
have
the
friendly
name
and
we
have
it
defined
as
a
gauge,
and
then
we
have
the
last
three
samples
right.
So
the
cool
thing
about
exposing
metrics
in
the
Prometheus
exposition
format
is
you
can
point
a
tool
like
Prometheus
or
say
if
you're
in
IKS,
like
as
your
monitor
to
say,
look
I
expose
metrics
in
a
standard
format.
Can
you
please
scrape
my
metrics?
B
B
So
the
other
thing
I
was
able
to
do
is
this
are
like
a
notation
is
understood
not
only
by
Prometheus.
Actually,
what
is
it
as
your
container
insights
also
understands
these
annotations,
so
what
I
had
to
do
is
I
had
a
slightly
update.
My
this
is
the
config
map
that
powers,
the
configuration
for
the
azure,
monitor
and
I
had
to
say.
B
Oops
there
was
this
so
I
set.
The
interval
equals
one
minute
and
I
told
it
to
monitor
kubernetes
pods.
So
if
you
can
see
the
comment
right
above
it
when
monitor,
kubernetes
parts
is
true,
it
will
enable
scraping,
there's
the
scheme,
the
path
and
the
port
right,
so
one
cool
thing
I
can
show
you
is
like,
while
we've
been
talking,
I've
been
letting
this
thing
run
said
actually,
if
I
hop
over
close
this,
if
I
hop
over
into
my
cluster.
So
this
is
my
kubernetes
cluster
right.
This
is
in
Azure.
B
A
Well,
well,
it's
doing
that
maybe
to
get
out
a
chancellor.
Is
there
any
relation
or
overlap,
or
how
does
this
fit
in
with
like
project
tie
as
I
notice
here,
you're
manually,
configuring,
kubernetes
and
stuff?
Is
there
a
way
to
integrate
this
with
project
I
work
so
that
you
know
maybe
I'm
instrumenting,
my
application?
You
know
thanks,
so
there.
B
Are
a
couple
of
things
to
know
so
tie
today
uses
the
same
mechanism
so
if
you've
actually
used
I,
like
you
know
the
thing
where,
on
the
tie,
dashboard,
if
you
click
on
the
process
name
and
you
can
see
metrics
yeah
or
see
the
live
streaming
logs,
that
is
actually
using
the
same
mechanism.
It
talks
to
the
diagnostic
server,
so
that
is
the
share
tag.
B
What
so
like
right
now
we
are
like
you
know:
I'm
working
with
Justin
I'm
working
with
John
and
we're
trying
to
figure
out.
How
do
we
fully
like
integrate
this?
Because
ty
is
an
excellent
experience
in
the
inner
loop
like
I?
Don't
think
dotnet
monitor
would
give
you
as
cohesive
of
an
experience
when
you're
just
dabbing
your
services.
A
B
A
B
I
mean
like
the
the
Diagnostics
server
pit,
which
is
in
the
runtime,
is
here
to
stay.
We
already
have
supported
CLI
dueling
ty
uses
a
data
monitor
uses
a
a
lot
of
things
can
use
it,
so
that
will
definitely
like
survive
all
of
us
and
so
looks
like
that.
Ned
the
portal,
just
loaded,
I,
don't
know
if
there
was
like
some
outage.
B
Hopefully
this
query
completes,
but
what
I'm
saying
is
because
I
had
enabled
monitoring
off,
like
I,
had
enable
this
I
kind
of
keep
tripping
up
on
the
name,
because
I
had
enable
this
as
your
container,
the
insights
was
actually
scraping,
my
container,
so
it
scrapes
it.
Every
minute
collects
last
three
samples
and
I'm
actually
running
a
query
and
plotting
a
time
chart
of
like
the
allocation
rate
so
well.
A
B
B
Also
I'm
exposing,
like
I,
think
18
system
run
time
matrix
and
then
Microsoft
SP
nightcore
matrix,
so
what
I
was
just
trying
to
do
is
I
was
just
trying
to
plot
one
of
them.
Allocation
rate
is
actually
a
pretty
nice
one
to
plot.
Let
me
try
this.
Let
me
filter
the
last
30
minutes
that
might
make
the
query
executes
a
little
faster
I've
been
using
the
same
like
cluster
for
a
while
laying.
B
A
B
B
B
A
Okay,
I
will
include
this
link
on
the
on
the
stand
up,
links
that
I
shared
earlier,
and
then
we
also
have
your
blog
post
to
that
that
kind
of
overview
some
of
this
if
people
want
to
play
along
at
home
so
wow.
This
is
great,
sir
odd.
Thank
you
for
your
time
and
perfect
timing.
I
I
mean
this.
Is
it's
right
at
an
hour,
so
excellent.
A
A
pro
all
right:
well,
so
we
now
have
I,
don't
know
if
you
remember
the
dramatic
zoom
out
effect
we
used
to
have
on
old,
shows
who'd.
Do
a
dramatic
zoom
out
Damien
would
press
the
remote
and
zoom
out
on
the
camera
and
through
complicated
science.
Things
I
have
now
mostly
replicated
that.
So,
if
you're
ready
it's
time
for
the
dramatic
zoom
out
sure.