►
From YouTube: 2020-04-14 .NET SIG
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
B
A
A
A
The
end-to-end
stories,
like
it
looks
relatively
easy
to
fix,
so
I'll
be
mixing
them
right
away
other
than
describing
all
the
issues
here
and
hopefully,
I
will
have
like
in
to
end
including
dogs
in
the
next
couple
of
days
and
pretty
close
to
that
I.
Think
thanks,
yeah
I'll
be
taking
like
look
at
all
the
other
fears
in
tracing
areas.
Will
we
have
additional
contributors?
No,
we
need
some
more
upper
world,
so
I
will
propose
myself
to
be
added
as
an
approver
by
the
next
Sigma
T.
A
B
I'm
trying
out
the
activity
API
from
him
and
I
have
some
local
experiments
so
currently
that
new
new
package
is
released
as
a
private
job.
They
just
send
me
the
nougat
file.
I,
wonder
in
order
to
make
progress,
should
I
check
that
thing
into
our
master
repo
and
start
to
send
some
PR
to
do
the
like
tracing
API
change,
or
you
guys
would
prefer
me
to
do
that
in
another
branch.
B
A
B
Probably
not
just
a
dirty
thing
like
in
general,
people
were
checking
in
binary
file
to
the
Republic
I.
Think
daemon
is
like
currently
we're
not
even
hitting
beta
and
we're
doing
about
how
changes
I
think,
probably
just
to
accelerate.
It
makes
sense
like
like
idea
so,
for
example,
here
like
instead
of
creating
a
span.
This
is
the
new
from
the
API.
Can
you
see
my
screen?
Yep
yeah
and
I
want
to
make
some
changes,
so
my
idea
is
first
introduce
this
package
into
our
Mars
repo
and
start
will
build
this
like
listener.
B
So
we
can
pick
one
exporter
that
can
consume
the
data
without
having
to
remove
all
the
existing
Spanish
and
when
this
one
works,
so
you
can
either
use
this
one
or
you
spell
and
I'll
start
with
switch
existing
code
from
Spain
to
this
new
model
and
after
all,
the
codes
and
test
cases
switch
to
this
model.
I'll
clean
up
and
remove
all
the
existing
Spence
and
that'll
be
a
breaking
change,
but
I
think
for
alpha.
It's
probably
okay.
So
how
do
I
think
yeah.
A
C
C
Another
problem
yeah
the
only
thing
I
want
to
question
about
this.
We
need
to
make
sure
that
we
align
scary
with
dotnet,
which
is
car,
be
doing
it,
but
then
I
don't
want
to
switch
everything
all
the
spans
to
dotnet
implementation.
Then
I'll
quote
ourselves
in
a
media
love
like
non
released
version
for
like
for
another
year
and
we
wouldn't
be
able
to
release
out
like
open
city
so
yeah.
That's
the
only
coordination
effort
we
need
to
yeah.
B
B
So
I
think
for
now
I'm
going
to
add
this
without
removing
this
man,
so
people
would
either
use
this
or
use
the
spare
model
and
after
we
figure
out
the
exact
date,
we
can
start
to
the
span
API
and
sufficient
Harley
to
this
one
and
regarding
the
timer
I,
think
donut
folks.
They
they
are
going
to
give
a
preview
version
of
this
package,
and
the
package
should
work
for
the
upcoming
on
at
5:00,
and
it's
also
working
for
all
the
older
versions
that
we
support.
I
can
donate
like
4.6,
not
is.
B
C
B
I
think
we
should
wait
for
that.
The
current,
like
expectation
is
donating,
will
release
that
around
November
timeframe
and
I
think,
even
if
they
got
a
little
bit
delay
very
in
the
middle,
we
need
to
release
something
and
later
will
make
her
a
big
change
and
switch
to
the
activity
API.
That
means
we'll
have
open
climate
on
earth
like
major
version,
in
that
case,
I'd,
rather
wait
for
like
if
it's
like
one
month
or
two
months,
I
think
it
makes
sense
for
us
to
wait.
B
C
A
B
Besides
that,
I
have
a
question
regarding
the
vendor
specific
thing,
so
I
think
it's
probably
the
time
we
start
to
move
things
away
following
the
other
open
telemetry
model.
So
how
do
people
think
about
that?
Like
currently
at
least
I
know
like
we
have
Microsoft
application
inside
six
Potter
in
that
and
I'd
rather
clean
a
table?
Remove
that
from
the
repo?
So
do
we
know
like
like
who's
going
to
help
to
remove
the
other
vendor
specific
stuff,
and
what's
the
general,
like
preference,
I,
think.
C
You
just
like
port
is
why
he
will
just
Park
them
in
some
branch
and
say
like
if
you
wanted
to
take
it
and
remove
from
my
sir,
but
we
kept
vendor
specific
things
in
our
repository
just
to
paly
dated
everything
works
for
everybody,
so
we
I
think
it's
either
stay
in
our
welcome
a
little
bit
in
the
safe
point,
but
it's
fine.
If
yeah
I
mean
we
can
we
can
create
an
issue
saying
like
speak
happens,
and
by
next
week
we
can
do.
We
can
start
migration,
okay,.
B
D
Right,
let
me
present
here.
D
And
thank
Sergey
I
just
saw
your
message
this
morning.
So
I
know
that's
kind
of
inconvenient
for
you.
I
I
could
do
all
the
time,
but
I
just
saw
this
man
your
message
this
morning.
So
thank
you
for
making
the
effort
to
come
to
this
one.
So
the
idea
here
it
should
basically
describe
the
data
dog
net
Osterman
tation.
That
is
the
path
that
is
it.
Okay,
if
I
start
recording
only.
D
So
the
idea
that
I
have
here
I
think
what
people
want
to
understand
is
kind
of
the
steps
for
the
instrumentation
and
what
happens
I
to
write
a
new
integration
in
the
term
that
they
use.
So
this
is
our
view.
I
don't
go
over
details,
because
the
code
has
a
lot
of
details
about
handling
at
domains,
and
things
like
this
so
I'm
trying
to
focus
on
providing
a
general
view
of
how
it
works.
D
So
the
high-level
view
it's
a
CLI
profiler
using
the
traditional
callbacks
and
info
API,
is
that
we
have
four
sierra
profilers
and
they
may
think
that
it
does
I
think
we
should
discuss
this
a
bit
in
the
end,
but
the
idea
that
it
actually
replaced
the
calls
to
the
target
methods.
I
would
say
that
when
I
started
even
before
looking
at
their
code,
what
I
was
expecting
was
something
changing.
The
code
of
the
target
functions
itself.
The
target
methods
should
be
instrumented,
but
what
it
does
it
changes?
Actually,
the
calls
to
the
instrumented
methods.
D
It
has
a
configuration
in
a
JSON
file
that
actually
is
generated
from
managed
code
and
that
integrations
configuration
file
specifies
what
are
the
target
should
be
instrumented
and
what
is
gonna
replace
at
the
target?
What
is
the
wrapper?
That's
going
to
be
making
the
call
to
the
original
target
other
integrations
in
the
terminology
that
they
they
write.
They
are,
they
are
reading
managed
and
we
are
gonna
see
a
little
bit.
D
I
am
going
to
show
an
example
to
be
more
clear,
but
basically
they
provide
some
helpers
for
you
to
write
this
wrapper
and
some
attributes
that
are
also
used
to
generate
the
integrations
configuration
file
and
that
one
is
in
charge
of
doing
any
tracing
metric.
Whatever
you
want
to
do,
and
also
calling
the
original
intercepted
function.
D
So
I
think
to
give
this
a
better
perspective,
I
wanna
kind
of
show
the
integration
configuration
I
shows
on
the
side
here,
except
it
to
show
what
it
is.
So
basically
is
a
list
of
integrations
that
you
have
a
collection,
a
list
of
metal
replacements,
so
the
method
replacement
identifies
the
caller,
usually
just
specify
the
assembly
that
you'll
be
calling
the
target
that
you
want
to
replace.
So
it's
possible,
for
instance,
to
say
I,
wanna
method,
XYZ
to
be
intercepted,
but
only
for
I
specific
caller.
Most
of
the
integrations
that
are
there
don't
use
that.
D
But
that
is
a
possibility
that
exists
on
their
current
implementation.
The
target
identifies
the
type
method
and
versions
that
you
wanna
target
for
a
give
interception.
So
you
can
do
use
that
version
school
target,
specific
things
like
they
have
a
elastic
version
5.
They
have
a
different
integration
for
elastic
version
6,
and
this
kind
of
thing
you
can
handle
this
kind
of
different
versions
via
specifying
minimum
and
maximum
version
for
each
target.
D
So
just
they
intercept
much
more.
They
have
implementations
for
much
more
come
back
soon
on
the
profiler,
but
I
think
for
what
I'm
trying
to
show
here
the
method
wrapping.
The
important
thing
is
when
never
a
module
finish
being
loaded.
They
are
gonna
map
the
module
ID
of
that
method,
with
any
replacement.
That
applies
so
from
that
configuration
that
we
saw
before
they
are
going
to
be
at
all
for
this
method
for
this
module,
we
have
all
these
replacements
that
are
possible
to
be
applied.
D
So
in
that
sense,
if
the
the
module
calls
very
different
methods
that
our
target
should
be
instrumented,
our
step
is
going
to
happen.
So
when
the
compilation
the
JIT
compilation
starts,
they
have
this
map
ready
and
then
they
are
going
to
check
for
that
module.
Whatever
needs
to
be
replace
it,
and
here
is
where
they
do
the
il
rewrite
and,
as
I
said
what
they
do
is
they
are
going
to
look
for.
The
calls
to
the
function
that
they
target
and
replace
with
the
calls
to
the
wrapper
once
more.
D
D
So
now
talking
about
the
wrapper,
the
wrapper
is
written
in
pure
managed
code
decorated,
with
attributes
to
express,
what's
going
to
be
intercepted
by
it.
What's
the
target,
it
doesn't
have
any
reference
directly
to
the
type
the
target.
So
that
means
that
it
doesn't
reference
the
package
from
the
target,
but
it
also
just
deal
with
the
primitive
types.
D
This
function
that
you
write,
the
wrapper,
I'm
gonna,
show
in
the
next
slide
and
I
think
you'll
be
clear,
but
basically
you
wear
the
three
parameters
that
helps
build
the
code
that
is
going
to
actually
call
the
original
function.
So
you
need
to
be
take
care
when
you
write
the
the
wrapper
function
to
tell
the
instrumentation
generates
spermatic,
whatever
you
are
doing
and
also
do
any
reflects
from
that,
you
may
need
to
start
to
add
data
to
expand
and
I
am
metric,
is
whatever
as
a
label
or
something
so.
B
D
B
B
C
It
still
are
in
CR,
you
need
to
attach
profiler
first
before
it
started,
and
only
then
you
can
ask
for
Ajit,
so
you
already
need
to
have
profile
loaded,
it's
a
limitation
that
they
wanna
get
IDO
but
see
you
like.
In
the
last
version
at
least
you
have
to
attach
a
father
first
and
then
you
can
rigid
or
intimate
method,
but
profile
should
already
be
there.
B
The
second
question
is
a
like
similar
thing
regarding
to
the
limitation
from
donut
framework,
so
you
can
only
have
one
profiler,
and
so
people
have
multiple
profilers,
normally
I've
seen
what
people
do
is
they
have
a.
They
have
a
proxy
where
they
listen
of
the
profiler
events
and
they
distribute
that
to
multiple,
like
like
pseudo
profilers
in
the
chain
and
I
wonder
if
this
is
part
of
the
profiler
it
is
not
so
are
they
going
to
coexist
with
other
profilers
with
some
some
like
upper
level
protocol,
or
this
is
exclusive.
D
E
Questions
all
since
it's
like
related
it's
about
tiered
compilation.
So
now
there
are
two
passes
on
JIT.
Does
this
affect
this
at
all,
like
I,
said,
I
think
it's
thought
Nick
or
three?
Oh,
that
came
up
with
that.
So
I
guess
it's
more
of
a
question.
Does
data
dog
integration?
Does
it
work
with
dog
or
three
this
instrumentation?
If
it
does,
it
probably
means
it's
fine.
Yes,.
D
E
D
E
D
E
D
Test
this
with
with
exception,
but
I,
do
expect.
As
I
said,
the
code
should
be
there
and
there
are
other
pdbs.
They
should
be
also
the
the
original
code
should.
If
there
is
a
PDB
there,
you
should
get
line
numbers
and
everything
you
know,
because
you
are
just
replacing
the
culture.
The
original
method
we
for
culture
that
another
one
that
Denning
is
gonna
check
called
the
original
method.
So
from
that
point
on,
they
stack
should
be
fine,
make
sense.
D
No,
no,
these
are
good
questions.
You
know
that.
That's
why
I
think
the
idea
is
to
bring
this
here.
So
we
can
have
all
these
questions.
I
can
validate
the
rigid
question.
I,
don't
think
it's
supported
and
like
I
definitely
can
check
they
stacks
in
cases
of
exception,
so
here
just
to
illustrate
the
integration
code
that
one
needs
to
write.
So
there
is
this
target
that
is
actually
part
of
the
runtime.
That
is
a
the
HTTP
message
Handler
and
there
is
a
specific
abstract
functions
and
I
think
that
is
being
target
so
below.
D
D
D
Helper,
they
help,
but
they
they're
rapper
that
you
wrote
since
it
needs
to
make
the
call
to
the
original
code.
You
need
to
do
it,
that's
done
via
il
emit
by
named
code,
and
they
provide
a
bunch
of
helpers
to
generate
the
necessary
code.
So
hearing
instrumented
method,
you
see
how
one
uses
the
this
helpers
to
generate
the
code.
The
delegate
that's
gonna
make.
Finally,
the
call
at
the
time
of
your
choice
in
the
rapper
that
you
created
so
here
below.
When
you
see
they
await
on
the
second
ballot,
they
send
a
sink.
D
Otherwise
you
are
not
going
to
be
be
able
to
do
this
kind
of
interception.
It's
a
design
choice
that
is
pros
and
cons
in
in
both
choice.
This
one
destroys
our
rewriting
the
cause
makes
very
flexible.
Like
oh
I,
just
wanna
intercept
XYZ
from
module
ABC,
you
know,
so
it's
a
design
choice.
There
is
also
does
not
reference
target
our
assemblies.
D
D
Here
is
just
a
summary
of
what
I
consider
from
my
perspective,
the
main
features
its
Linux
and
windows
compatible
I
tested
on
both,
and
it
worked
just
fine
it.
It
goes
down
to
dotnet
4.5
I
didn't
test
that
particularly,
but
that
should
work
I,
don't
see
why
not,
which
requires,
when
you
are
coding,
if
you
want
to
keep
that
down
level
support,
you
have
to
be
careful
about
not
introducing
dependencies
that
are
even
thought
Nets
than
that
you
all
kind
of
otherwise
you,
but
you
break
dotnet
for
five.
D
D
D
C
D
So,
if
I
understand
your
question,
correct
is
about
the
reliability
and
the
thing
I
should
be
fair.
I
didn't
do
stress
tests
on
these
ideas,
exploration,
users
and
testing.
So
what
I
saw
for
following
kind
of
these
three
Ford
cases,
I
didn't
hit
any
problem?
That's
why
I
didn't
see
any
crashes
or
stacks
or
things
like
this
I.
D
D
A
bunch
of
really
so
yeah
that
that
was
what
I
found
in
my
exploration
and
that's
what
I
I
want
to
present
I
I.
Think
if
you
guys
have
more
questions
I
it
that
I
can't
provide
the
answers
right
now.
I
think
I
already
have
two
follow-ups,
one
regarding
the
stacks
and
the
other
regarding
widgets
but
I'm
open
to
try
to
answer
any
questions
that
you
guys
may
have.
D
D
E
D
E
I
have
one
question:
I
didn't
like
I
didn't
I
forgot
about
in
the
middle
anyone
interrupt
so
those
interceptor
methods
that
we
write,
they
use
reflection,
dot,
emit
right,
I
Alamut.
Yes,
that
is
done
at
runtime.
I
did
I
get
that
right.
So
that's
just
incompatible
with
äôt
scenarios
like
mono
IOT
and
yes,.
E
D
F
E
It's
a
good
point.
It's
a
good
point.
I
forgot
to
make
sure
that,
like
I've,
been
a
little
bit
away
for
a
few
months
but
like
before
there's
this
discussion
of
having
auto
instrumentation,
but
that
would
not
replace
manual,
instrumentation
and
I
wonder
where
we
stand
nowadays.
Is
it
still
true
where
this
would
be?
We
still
have
two
options
manual
and
an
auto
experimentation.
Yes,
so.
D
There
is
a
tap
or
specifying
kind
of
what
should
be
the
desirable,
so
it's
desirable
to
have
zero
touch,
but
then
we
we
kind
of
fall
back
about
kind
of
what's
possible
or
they
seek
decides.
You
know
the
initial,
it's
very
desirable
to
be
zero
touch,
but
I
think
the
decision
is
up
to
us
right.
If
you
are
gonna,
follow
that
or
not
yeah.
C
E
Yeah,
it's
like
don't
get
me
wrong.
I.
Think
personally,
I
think
this
is
great.
I
took
a
look
as
well
what
they
announced
a
the
dog
was
offering
all
theirs
to
cage
I'm,
just
thinking
of
like
potential
side
effects
right,
so
there
will
be
some
scenarios
so,
for
example,
if
summary
in
iOS,
which
is
for
sure
a
ot
there's
no
JIT
there
like
none
of
this
would
work.
So
are
we
gonna
focus
on
also
maintaining
twice
like
also
the
manual
version
of
all
these
instrumentations,
because
we
would
require
basically
to
maintain
all
things
right.
D
E
F
480
scenarios
like
what
would
make
to
make
them
work,
so
we
need
to
get
rid
of
all
the
data
meets
and
is
it
possible
to
do
so
sorry,
I'm,
having
trouble
understanding
the
baby,
so
gonna
mention
that
for
a
lychee
scenarios,
cheat
in
meat
and
ayah
limits
essentially
right
is
not
gonna
work.
So
what
would
make?
What
would
it
take
to
make
it
working
for
edges
tinnitus?
What
should
be
changed
is
like
design
issue.
Oh,
it's.
E
Just
the
approach
chosen
for
this
or
instrumentation
wouldn't
work,
because
the
relies
on
io
limit.
So
it's
like
I
assume
that
this
it's
kind
of
like
poly,
ril,
weaving
approach.
It's
fine
because
it
changes
the
the
executable
the
DLL
and
it
will
be.
It
could
go
through
the
a
ot
bit
an
output
machine
code
and
then
run
that
would
work.
But
what
we
do
here,
apparently
the
code
that
we
write
has
a
limit
in
it.
F
C
I
suggest,
as
next
steps,
either
or
next
submission
core
might
be
between
cig
meetings.
We
can
scare
another
time.
I
can
do
presentation
of
she'll
our
instrumentation
engine
and
then
the
big
trade-off
that
we
need
to
make
is
I
mean
we
want
to
proceed
with
other
instrumentation
that
we
need
to
choose
whether
to
take
instrumentation
engine.
That
has
a
less
functionality
right
now,
but
it
has
more
features
like
it
doesn't
disable
inlining.
D
C
Yes,
so
I
mean
actually
see
a
lot
of
instrumentation
engine
is
just
a
proxy
that
enables
like
multiple
profiles
to
work
and
in
mind
that
we
trying
to
install
it
in
many
places
are
pre-installed
and
then,
on
top
of
it,
we
have
a
module
that
injects
court
in
the
target.
Method
and
I
can
talk
about
this
module
yeah.
D
One
thing
that
crossed
my
mind
with
this
talk
about
alt
I
I'm,
not
sure
what
the
profiling
recommendations
regarding
that.
But
one
thing
that
we
could
do
is
I.
Are
we
right
at
the
the
managed
source
and
the
manage
parts
they
the
il
itself,
not
using
the
profile,
but
that's
a
pre
compilation
step
no,
but
but
that
works
too.
So.
E
Right
then,
yeah
that
goes
before
the
äôt
compiler,
so
that
that
should
work.
There's
two
some
constraints
in
äôt
snares,
I
all
emit
is
one
of
them
and,
like
the
linker,
just
deletes
code
that
it
can
trace
usage
to
so
you
might
have
to
put
on
that
link,
X
and
all
the
types
that
you
would
want
to
link
or
not
in
the
meet.
But
that's
just
unrelated.