►
From YouTube: 2020-04-28 .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).
C
C
Think
we
can
start
so
if
anyone
is
new
here,
please
go
ahead
and
update
your
name
in
the
list
of
attendees
I,
don't
see
any
man
new
yeah,
there
are
mean
folks,
welcome
in
this
house
Sergey
for
sending
aboard
theater
instrumentation
engine.
That's
the
main
agenda
for
today,
but
before
that
I'll
either
short
update
on
the
progress
you
know,
we've
been
waiting
for
certain
things
from
matrix
thanks,
which
has
seemed
like
good
progress
in
the
last
couple
of
weeks,
not
only
specs,
the
photo
representation
is
also
getting
some
updates.
C
It's
not
yet
mastered
still
working
focus,
but
mostly
I
expect.
It
should
be
ready
like
this
weekend
as
soon
as
they
are
ready.
I'll
start
implementing
the
same
in.net
SDK
other
than
that
we
had
very
minor
changes
thanks
to
or
contributors
I,
both
of
the
both
contributors
who
worked
heavily
on
our
repo
last
week
are
not
able
to
join
the
meeting.
C
I
guess,
but
thanks
for
the
contribution
in
case
you
do
read
the
upcoming
changes
in
PCL,
which
would
change
the
way
we
treat
spans,
because
there
were
several
condition
for
folks
who
were
contributing
about
what
what
exactly
the
changes
are.
So
I
have
added
the
link
to
the
design
discussion
about
upcoming
changes.
C
Yes,
there
are
few
PR
spending
we
had
like
1015
it
active
at
one
point,
but
we
are
now
down
to
less
than
five.
So
if
anyone
has
three
cycles,
please
go
ahead
and
in
tribute
and
thanks
everyone,
including
follow
who
reviewed,
PRS
I,
don't
really
have
any
other
update.
So
I'll
ask
if
anyone
else
have
any
comment
optics
to
discuss,
if
not
I
will
hand
over
to
Sergey
to
do
the
presentation
on
Ceylon
instrumentation
engine.
E
D
D
The
next
step
is
to
like
to
the
site
by
sizing
without
removing
all
the
existing
tracer
and
Spanish,
but
introducing
the
activity
code
on
the
new
activity
and
me
I'll,
try
to
make
sure
all
the
existing
test
cases
still
pass
and
eventually
we
can
get
rid
of
the
tracer
and
entirely
to
the
donut
guy.
If
that
works.
D
D
C
C
C
Has
issues
a
new
milestones
and
when
you
click
on
my
train,
you
can
see
when
it's
expected
date
of
arrival.
For
that
milestone.
I
say
those
milestones
are
really
off
it's
already
like
two
months.
It's
updated
to
more
realistic
one.
So
people
like
many
folks
were
asking
like
when
is
this
feature
coming
and
by
looking
at
the
status
of
my
system
status?
If
it
really
sounds
like
nobody's
updating
itself,
just
make
sure
it's
updated
correctly
to
a
realistic
schedule,
because
we
have
dependency
on
dotnet
changes.
B
A
related
question
because
I
was
kind
of
looking
to
that
issue
that
Mike
open
with
the
beta
issues,
I'm
kind
of
treating
that
as
a
kind
of
priority
list
for
the
dotnet
and
I'm
trying
to
pick
up
stuff
from
there.
I
just
submit
my
first
PR
today
and
later
I'm
thinking
looking
at
there.
But
if
there
is
other
priorities
that
you
you
are
aware,
let
me
know
or
post
in
the
channel
and
if
I
have
a
chance,
I
try
to
pick
up
stuff.
C
C
So
you
do
like
modified
so
that
it's
very
obvious
for
everyone
that
we
are
waiting
for
changes
from
the
dotnet
framework
itself
and
the
package
which
you
are
waiting
for
will
not
be
officially
released
as
stable
until
November,
but
there
will
be
preview
bits
like
every
month
from
now.
So
we
need
to
include
this
fact
in
the
butyl
readiness
tracker.
So
everyone
is
aware
that
ok,
we
are
waiting
for
this
to
happen
before
ot
a.net
can
call
itself
as
better
so
I'll
update
that
that's
an
item.
A
C
G
Hello,
nice
to
nice
to
be
here.
This
is
the
first
time
I've
joined
this
meeting.
I
am
my
name's
Alan.
Yes,
you
know
and
I'm
from
New
Relic
I'm
an
engineer
on
our
net
agent
team
and,
of
course,
we've
also
been
developing
newer
products
that
use
the
open,
telemetry
API.
So
we're
really
excited
about
them
and
excited
engaging
more
in
this
community.
Okay,.
G
A
H
Nice
to
meet
everybody,
my
name
is
Eric
Lucas
I'm
from
New
Relic
as
well
too,
and
I'm
the
product
manager
for
the
dotnet
agent
team
and
yeah
I
just
want
to
echo
that
we're
we're
excited
about.
What's
going
on,
you
know
an
open
telemetry
space
here,
and
this
is
definitely
something
that
we
see
is
a
is
a
priority
for
us,
and
so
we
just
want
to
start
getting
more
involved.
So
you'll
definitely
see
me
I'm
lurking
in
these
meetings
coming
up.
Okay,.
C
Yeah,
so
if
you
have
like
any
specific
requirements
from
the
Dortmund
team
that
we
mentioned
it
earlier,
that
dota
team
is
available
for
joining
this
meeting.
If
we
have
specific
questions,
you
can
post
it
it
in
the
shade
north
as
an
question
or
agenda,
and
we
can
make
sure
the
right
people
from
dotnet
team
is
here.
If
you
help
specific
questions
that
Rick,
you
are
not
risking
welcome.
I
C
E
Absolutely
I
pasted
a
link
to
the
document
I
combined
out
of
many
other
texts.
I
have
and
let
me
start
presenting
so
I
resent
the
same
document.
So
you
can
read
it
at
your
pace
and
you
can
listen
for
me
whatever
you
prefer
and
we
can
not
I
keep
adding
a
comment
right
in
the
document.
So
I
hope
that
those
doctors
who
live
longer
than
this
presentation.
A
A
E
Okay,
so
and
it's
fun,
okay,
do
I
need
to
make
it
bigger,
yeah,
I,
guess
I
always
also
think
so.
Last
time
power
presented
data,
doc,
profiler
and
this
time
I
wanted
to
talk
about
steel,
our
instrumentation
engine
and
intercept
extension
for
that-
and
this
is
two
separate
pieces
of
code
and
I
will
talk
about
why
we
need
both
of
them
and
how
they
can
be
used.
So
Solaris,
imitation
engine
is
something
that
created
by
dotnet
team
and
it
was
the
main
purpose
of
Scylla.
Instrumentation
engine
is
to
solve
the
problem
of
severe
limitation.
E
That
CL
doesn't
allow
multiple
providers
to
be
enabled
for
the
same
process,
so
it's
literally
a
multiplexer,
but
it's
not
simple,
multiplexer
its
multiplexer
on
steroids,
so
it
not
only
multiplex
callbacks
of
profanity
guy.
It
also
occurred
in
eighths
called
an
injection,
for
instance,
and
gives
you
some
high
level
representation
of
aisle
code,
three
that
you
can
modify
and
calculate
with
other
modifications
of
this
of
this
code.
So
it's
quite
powerful
and
quite
easy
to
code
against.
E
We
have
you
who
also
want
to
use
profanity
to
inject
code,
to
do
some
other
analysis
and
a
p.m.
so
it's
multi
like
the
limitation
of
solarz.
It
doesn't
allow
to
run
multiple
providers,
wouldn't
allow
customers
to
use
benefit
of
having
application
secured
by
one
vendor
and
minded
by
another
vendor.
So
it's
not
only
about
like
two
vendors
who
wants
monitoring
compete
with
each
other,
so
yeah.
A
E
Business
limitation,
we
started
to
invest
into
this
multiplexer,
and
now
this
monitor
has
a
pluggable
mechanism
to
enable
extensions.
You
can
either
enable
extensions
in
configuration
time
when
you
copy
your
dll
native
GL,
o
and
whatever,
like
binders,
you
need
into
some
folder
and
might
if
I
can
pick
file,
it's
a
XML
or
you
can
do
it
in
run
time.
By
calling
some
API
function
like
comb
function,
you
can
just
call
this
function.
It's
called
attach,
profiler
or
attach
extensions,
unlike
that
and
then
provide
a
pass
to
you.
Dll
and
this
deal
will
be
loaded.
E
So
there
are
two
making
enable
extensions,
other
expensive
design
notes.
Here
you
can
find
it
it's
a
public,
open
source
extension,
so
you
can
redesign
nodes
and
all
the
components
that
instrumentation
engine
has
and
I
can
say
that
that
we
try
to
install
instrumentation
engine
in
many
platforms.
So
in
many
situations
you
have
instrumentation
engine
already
loaded
in
your
application
to
provide
some
functionality
that
you
may
not
even
notice
at
first
and
yeah.
So
this
is
a
civil
instrumentation
engine.
E
On
top
of
our
instrumentation
engine
we
created
the
intercept
extension
most
is
in
the
intercept.
Extension
was
used
by
application
insight
to
provide
support
of
monitoring
for
all
their
frameworks
where
we
have
an
instrumented
framework
itself.
Yet
so,
let's
say
we
implement
sequel
before
net
core
1
I
believe
and
that
that's
why
we
needed
to
go
to
six
actually
44.7.
It's
already
was
instrumented.
So
before
4.7
seeker
wasn't
instrumented
and
we
needed
to
insert
inject
court
if
application
is
running,
sonic
lowers
and
dotnet
four
point
seven.
So
this
extension
was
provided.
E
E
This
is
a
nougat
package
that
you
install
in
compiled
time
in
your
in
your
application
and
then
I'll
talk
more
about
it
later
and
then
you
initialize
extensions,
just
omit
it,
and
then
you
specify
which
method
you
want
to
instrument
in
this
case,
I
want
to
show
how
to
instrument
SMTP,
sent
and
scientific
lines,
sent,
method
and
I
specify
that
this
method
is
in
system,
DLL
system
assembly
and
here's
a
callback
I
want
to
be
injected
into
this
send
method.
It's
quite
telling
that
on
begin
will
be
caught
on
begin
on.
E
E
One
is
I,
think
it's
mail,
something
mail
message,
so
you
can
tale
take
argument
one
and
take
it
subject
and
assign
it
as
a
data
of
your
chili
emoji
I
mean
this
is
application
size
example,
but
I
mean
it
may
be
open
today,
materially
and
then
on
end
exception.
Yeah
interesting
thing
here
is
that
you
can
extract
operation
as
a
object
that
was
passed
in
a
and
in
a
in
an
argument.
E
So
not
here
you,
you
know
begin
extension
in
begin
call
back,
you
returned
operation,
object
and
the
same
object
will
be
passed
into
own
exception
call
back
here
and
you
can
get
this
concept
back
to
operation
and
then
at
whatever
more
details
you
want
and
then
stop
operation
like
in
in
open
cinematic
case.
It
will
be
stopped
span.
E
So
this
is
a
basic
of
how
callbacks
works
and
it's
quite
powerful,
because
I
mean
it's
all
managed
cause
you,
you
literally
like
you,
have
a
nougat
package
and
before
that
you
enable
our
instrumentation
engine
by
design
conveyor
meant
variables.
But
after
that
you
only
have
managed
code,
you
called
manage
to
decorate
method,
and
then
you
provide
managed
callbacks
that
are
defined
in
your
library.
So
you
don't
need
to
install
anything
on
machine.
You
need
you
don't
need
to
like
bring
additional
libraries.
E
Then
you
pass
a
return
value
and
again
all
the
arguments
like
this
value
and
all
the
arguments
and
note
here
that
return
value
we
override
return
way
leaves
whatever
this
POSIX
callback
will
return.
So
this
can
be.
It
is
very
powerful
because
you
can
in
case
of
I,
think
method.
For
instance,
return
value
will
be
tasks,
so
you
can
return
new
tasks.
Let's
have
a
continuation
on
a
previous
task.
E
So
it's
a
quite
powerful
in
this
regard
and
this
one
of
the
use
we
had
for
for
this
intercept
and
then
on
exception
is
pretty
similar,
except
there
is
no
return
value
and
you
can
either
write
exception
so
like
it
was
just
I
think
the
decision
to
nautical
at
exception
was
made
because
it
was
just
easier
to
implement
and
it
didn't
like
it
allowed
to
limit
a
number
of
conditions.
We
need
to
inject
into
customer
code
and
then
just
return
original
value
and
that's
it.
E
So
you
need
to
inject
callbacks
in
the
replicas,
and
this
interaction
is
enabled
by
some,
like
small
hoc
I
mean
serial
instrumentation
engines
at
this
table
by
Microsoft
typically
has
additional
extension
already
pre
enabled
and
this
extension
or
does
it
in
terms
of
callback
references
like
it
insert
callbacks
into
a
mask
or
lip
and
reference
to
these
callbacks
from
all
the
assemblies
in
the
world.
It's
a
MS
calypso,
we
inject
into
a
mask
or
lip,
and
all
the
libraries
already
have
reference
to
a
mask
relief.
E
E
E
So
for
this
one
we
have
this
collection
of
callbacks
and
by
far
my
method,
ID
v
search
for
callbacks
for
on
begin,
go
back
to
call
for
this
method,
ID
and
then,
when
we
inject
code
into
into
the
target
method,
that
code
will
call
this
own
begin
callback
with
specified
method.
That
is
a
constant
value.
So
the
score
by
causing
to
on
begin
with
specified
value.
E
E
So
this
trial
allows
to
add
callbacks
form
edit
ID,
you
can
add
callbacks
on
begin
and
end
and
on
exception,
and
this
method
to
register
those
callbacks
by
this
method.
Id
in
that
collection
that
I
chose
before
so
this
kind
of
indirection
introduction
call
it's
very
cool,
I,
really
like
how
it
was
done
and
if
I
spend
so
much
time
on
it.
So
as
you
know
that
the
older
callbacks
defined
in
managed
code,
you
call
decorator
managed
code.
E
So
if
you
have
multiple
up
domains,
then
every
abdomen
will
host
its
own
version
of
intercept
and
it
may
be
its
own
version
of
its
decade.
I've
been
caught
of
its
own
version
of
callbacks
all
the
static
superior
abdomen,
so
all
the
statics
in
certain
chemical,
if
you'll
also
be
pure
abdomen.
So
whenever
you
instrument
a
method,
call
box
will
be
called
for
every
abdomen,
so
like
for
first
abdomen,
there
will
be
Co
box
registered,
so
it
will
be
quote
for
next
up
the
main.
There
may
be
no
callback,
so
nothing
will
be
called.
E
So
this
is
multiple
demand,
support
and
short
summer.
Is
that
serious
limitation
engine?
It's
a
way
that
myself
trying
to
go
forward
for
multiplexing
solutions,
and
we
have
a
few
partners
to
be
working
with
it's
already
working
for
many
internal
scenarios
like
we
have
functionality
like
production,
breakpoints
from
visual
studio
and
application
sites
and
snapshot
debugger,
it's
all
using
the
same,
like
so
implemented
extensions
to
see
what,
as
fermentation
engine,
it
works
reliably.
E
Well,
however,
there
is
some
work
on
going
to
prove
that
it's
maturity
on
its
partners
and
I
know
that
I
heard
that
New
Relic
is
trying
it
and
there
were
some
problems
to
make
it
work.
So
this
work
is
ongoing,
so
I
just
want
to
make
sure
we
all
sin.
It's
not
like
it's
human
progress
actually
kind
of
in
the
works,
intercept
extension
only
implemented
for
Windows
only
and
it
does
support
dotnet
core,
mostly
because
there
is
no
like
technical
limitations,
mostly
because
of
purpose
of
this
intercept
called.
E
Big
amount
of
investments,
I,
don't
know
how
big
that
amount,
comparing
to
making
data
doc
profiler
more
aligns
with
your
instrumentation
engine
future,
but
it's
non-trivial,
plus
as
I
didn't
mention
it
before
intercept
intercept
extension
doesn't
allow
code
injection
on
startup,
so
you
can
just
set
environment
variable
and
intercept
you
be
loaded
by
itself.
This
needs
to
be
a
separate
model
and
in
different
scenarios
you
can
use
different
approaches
for
historical
application,
size
we're
using
HTTP
modules
registering
in
the
web
config
or
some
other
mechanisms
to
enable
this
bootstrap
logic.
E
E
So
there
are
a
few
links.
I
like
this
one
is
MSR.
I
tried
to
signal,
intercept
extension
to
do
some
dynamic
instrumentation
of
methods
based
on
call
stacks,
so
they
were
analyzing
errors
or
performance
problems
and
based
on
this
call
stacks.
The
Edit,
callbacks
and
specific
methods
from
this
call
stack
and
then
started
collection
parameters
for
that.
It's
kind
of
like
dynamic
instrumentation
since
intercept
extension,
supports
jeet
and
you
can
insert
callbacks
later
and
can
then
continue
with
callbacks.
E
It
was
quite
powerful
for
this
kind
of
dynamic
scenarios.
When
you
don't
know
what
you
want
to
monitor,
you
just
throw
this
module
there
and
it
tries
to
analyze
cord
and
then
inject
callbacks
in
the
proper
functions.
It's
quite
powerful,
it's
from
Microsoft
Research,
but
they
had
a
prototype
working,
so
I'm
quite
excited
about
it.
E
B
B
B
So
so
the
because
you
mention
Windows
only,
but
you
mentioned
for
the
intercept
extension,
the
DCI
profiler
itself,
the
code,
the
native
code-
is
already
working
with
Linux
dotnet
or
let
me
rephrase
the
question.
The
borderline
between
the
CLR
ie
in
the
intercept
extension
is
not
very
clear
to
me,
which
is
which
you
know.
E
So
she'll
an
extension,
a
salon,
instrumentation
engine
is
just
a
multiplexer
multiplexer
on
steroids,
so
you
can
install
it
and
if
you
didn't
register
any
extensions,
it
will
literally
do
nothing.
So
it
will
try
to
vote
extension.
It
will
discover
that
there
are
no
extensions,
loaded
and
I
think
it
will
do
some
very
basic
functionality
of
I
mean
it
wouldn't
disable
any
optimization
of
court
or
any
any
way
that
it
will
just
track.
E
Assembly
flowed
I,
think
for
some
internal
optimizations
in
case
somebody
will
vote
extension
in
runtime,
so
the
basic
think
it
will
be
doing
then,
on
top
of
instrumentation
engine,
there
is
a
small
piece
of
hack
that
is
implemented
specifically
that
you'll
enjoy
in
inter
this
callbacks.
So
this
is
pre-installed
with
many
installations
of
see
our
instrumentation
engine,
but
it's
not
necessarily
there
all
the
time.
So
this
is
the
way
to
overcome
another
limitation
of
dotnet.
That
dotnet
doesn't
allow
to
inject
callbacks
into
Emma's
core
lip
after,
like
in
runtime.
E
So
after
a
massacre
reports
already
loaded
22
it
in
very
being
once
see
what
we'll
leave
this
limitation
and
if
they
will
leave
this
limitation,
then
this
logic
will
not
be
needed
any
longer,
but
nevertheless
yeah.
This
is
a
multiplexer,
but
then,
on
top
of
this
multiplexer
there
are
certain
extension
that
supplied
by
Microsoft
that
enables
matters
like
snapshot,
debugger
and
source
extensions
needed
to
be
cleaned
from
pre-loaded,
so
pre-configured
so
typical
way
to
pre-configured
assignments,
to
register
them
in
XML
file
and
copy
binary
into
the
disk.
E
So
this
XML
file
will
refer
to
this
extension
and
whenever
instrumentation
engines
both
it
will
go
this
pre-configured
extension
from
the
list
and
then
on
top
of
it.
You
can
also
do
voiding
of
extensions
in
runtime.
So
in
runtime
you
can
say
like
I
want
another
extension
to
be
load
it
and
supplies
a
path
to
a
native
0,
and
this
developer
would
be
Algol.
That
is
an
extension
and
also
what
you
can
work.
B
E
So
you
see
a
lot
of
simulation
engine
supports
all
of
the
verses
of
dotnet
that
are
supported
and
it's
it
supports
Linux
and
windows
everything.
So
it's
in
quite
active
development,
intercept
on
other
side.
Is
it
family
that
we
initially
thought
would
be
a
very
good
addition
to
instrumentation
engine?
And
now
it's
in
in
the
midst
of
like?
Do
we
really
need
it
and
we
want
to
kind
of
like
envious
into
it
or
we
don't
really
want
it
and
it
will
just
stay
in
a
concurrent
state.
E
E
Ultimately,
we
need
to
decide
if
this
seems
to
be
the
way
we
want
to
proceed
me
to
decide
whether
we
want
to
proceed
as
this
intercept
extension
as
part
of
open,
telemetry
or
intercept
extension
part
of
dotnet
and
all
part
of
instrumentation
engine.
So
maybe
we
can
even
like
put
it
in
into
the
instrumentation
engine,
and
this
way
it
will
be
developed
kind
of
by
Microsoft
ish.
I
E
It
only
works
for
our
desktop
version
of.net
and
it's
not
about
technical
limitation.
Just
like
her.
It
was
never
optimized
for
that.
It
has
some
beautiful
drawbacks
because
we
in
the
surface
tension
was
building
in
times
of
4.5
and
4.6
frameworks
when
region
support.
Wasn't
that
extensive.
So,
ideally,
some
rigid
support
needs
to
be
added
to
intercept
extension,
so
it
will
be
even
more
performant
but
I
mean
it's.
It
doesn't
disable
code
optimization
and
doesn't
disable
inlining.
B
Yeah
that
that's
a
thing
that
I
was
thinking
is,
and
even
because
of
the
approach
that
I
mentioned
last
time,
that
data
dog
does
that
it
replaces
the
calls
not
the
specific
method
that
makes
they
start
up
especially
kind
of
bad
I
did
some
kind
of
informal
test,
but
I
reread
Specter
that
and
that's
true.
The
data
dog
model,
the
startup
time
is
usually
very
bad,
because
you
want
to
get
a
bunch
of
things
that
they
won't
expect
how
the
gt2
should
do
all
this
stuff.
You
know
so
this
is
this.
B
E
E
This
example-
and
here
you
can
see
so
start
up
so
first
you
enable
our
instrumentation
engine
here,
so
you
supply
this
core
profile
variables
and
then
you
supply
some
additional
variables
needed
by
instrumentation.
Engine
like
this
is
a
yeah.
This
is
just
extra
component
that
instrumentation
engine
requires
and
then
yeah.
This
is
all
like
this
only
need
so
now,
when
you
go
back
so
you
enable
instrumentation
engine.
This
way
you
didn't
enable
intercept.
E
Yet
you
just
enabled
instrumentation
engine
and
they're
good
I
think
about
instrumentation
engine
was
that
you
install
it
once
and
it
barely
changes
ever
so.
Ideally,
you
only
need
admin
privileges.
Once
while
we're
working
and
then
intercept
extension
itself,
you
go
to
packages
config,
and
this
is
intercepting
you.
So
this
is
what
you'll
bring
our
intercept
and
then
in
record
here
she
is
I
first
initialize
extension
and
then
I
asked
to
decorate
SMTP
my
clients
and
exactly
what
I
showed
before
in
the
in
the
document
and
I
supply.
E
This
on
beginning
on
end
on
exceptional
extension
are
callbacks,
and
then
here
I
call
send
and
when
I
with
this
thing,
she'll
be
called
I'll
before,
like
in
a
very
beginning
of
this
cold
is
on
beginning
a
big
cold
and
then
the
end.
This
callback
will
be
called
so
yeah.
So
this
is
a
code
example
that
you
can
finish.
B
B
B
The
case
then
I'm
looking
for
the
case
of
zero
touch
instrumentation,
because
we
do.
We
have
some
people
that
basically
don't
touch
their
code
for
this
kind
of
thing,
and
the
case
that
I'm
looking
is
kind
of,
because
here
you
need
to
added
in
the
program
in
the
sample
the
the
target
of
your
intersection.
I.
A
B
E
So
is
it
a
touch
typically
refers
to
some
environment
variable
scope
in
binaries,
and
you
can
achieve
that
in
multiple
ways.
You
can
like
in
I
spin
a
core
to
point.
One
and
above
you
can
configure
a
start-up
filter
using
convert
variable,
and
this
part
a
filter
will
go
someone's
court
and
then
man
squad
can
load
whatever
you
want
and
specifically
in
intercept
extension
in
ice
phonetic
classic
applications.
You
can
modify
a
webcam,
seek
and
configure
some
HTTP
module
that
you'll
be
loaded.
And
again
you
have
a
starting
point.
E
Now
things
got
tricky
if
you
don't
want
some
universal
solution
for
all
dotnet
or
you
don't
have
it
just
a
worker,
all
that
runs
from
like
from
Bosch
Shinji
and
you
you
want
to
instrument
this
worker
role.
So
in
this
case
you
want
to
look
like
profiling
KP,
either
to
or
some
native
quarter
to
so
the
data
dog
doing
like
some
intercepts
I'm
very
first
function
and
then
bought
all
the
managed
code
in
this
very
first
function.
So
that
part
is
missing
like
that
is
not
here.
E
So
I
can
Adam
and
say
that,
but
you
can
clearly
see
how
you
can
instrument
applications
through
web
config
or
you
can
do
it
through
in
variables
and
set
up
user
for
s
net
core,
so
yeah
that
is
so
intercept
only
solve
the
problem
of
injecting
callbacks.
Once
you
enable
some
managed
code,
so
it
doesn't
solve
the
attached.
G
This
may
be
kind
of
a
naive
question,
but
I
believe
you
kind
of
alluded
to
the
fact
that
you
know
the
intercept
extension
would
be
used
in
a
case
where
the
library
hasn't
already
been
instrumented.
Like
these
examples,
you're
showing
with
like
SMTP
client
is.
Is
it
Microsoft's
vision
to
begin
instrumenting,
those
there's
something
like
Diagnostics
or
sir
I'm,
not.
E
Sure
about
the
Sin,
City,
client
I,
doubt
okay,
I,
wouldn't
say
a
doubt:
I,
don't
know
it
just
called
coders
too
old,
but
in
general
we
do
want
to
instrument
everything
like
right
now.
We're
working
on
instruments
tinker
is
the
case.
We
already
instrumented
sequel
and
ent
different
work,
and
it
went
up
when
happy
history,
I
think
and
I
suppose.
Net
Authority,
instrumented,
so
G
RPC
is
already
instrumented
as
well.
So
we
trying
to
instrument
everything
like
the
vision
going
forward.
E
Is
you
don't
need
to
quote
inject
4x6
matters
you
you,
you
just
need
to
go
out
some
managed
library,
this
men's
library
will
subscribe
to
Diagnostics
or
so
activities
and
a
future
activities.
You
even
replace
span,
remember
the
first
part
of
a
meeting
and
then,
like
you
literally,
have
open
telemetry
already
there
and
you
just
need
to
hook
up
this
opens
element
into
exporter
and
the
get
your
data
on
the
back
end.
So
code
injection
and
intercept
only
needed
for
advanced
scenarios
like
if
you
want
to
instrument
something
that
wasn't
instrumented
before.
E
So
it's
actually
a
very
good
point
between
Poland.
Our
new
is
what
auto
instrumentation
group
is
about.
Is
it
about
okay?
I
mean?
Maybe
it's
about
ball,
but
like
maybe,
we
need
to
have
two
separate
work
streams
first
to
how
to
in
enable
code
so
how
to
enable
instrumentation
how
to
basically
load
some
managed
code
into
any
application.
E
You,
and
so
it's
a
zero
touch
enablement
and
we
can
enable,
like
all
the
diagnostic
source
based
instrumentation,
very
well-managed
code
and
then
second
work
stream
is
once
you
enabled,
and
you
subscribe
to
some
basic
functionality,
how
you
enable
more
through
code
injection
that
is
separate,
work
stream.
Perhaps.
J
It
could
expand
a
little
bit
on
that.
You
know
so
trying
to
stream
entering
that.
We
have
no
control
over.
Let's
say
race.
Client
has
because,
just
like
almost
like
a
lifelong
struggle,
we
were
trying
to
get
them
on
board
that
buys
em
I
mixed
a
girl
floaties
on
antagonistic
source
I,
don't
know
for
maybe
three
four
years
now
so
and
all
we
have
is
just
a
partial
instrumentation
through
some
callbacks
which
were
not
really
designed.
You
know
for
this
particular
scenario
of
working
with
agnostic
source,
for
example.
J
We
are
missing
a
radius
common
text,
so
in
general,
like
we
know,
was
a
common
fail
to
know,
but
we
have
failed
to
tell
customer
like
which
come
on
failed,
which
places
like
nice
feeling
of
anxiety
in
work
without
like
learning
a
details,
motor
sexually
wrong,
so
bytecode
instrumentation,
you
know
like
in
case
of
Java
I,
really
help
us.
You
know
like
to
to
have
a
scenario
implemented
and
he'll.
Prepare
instrumentation
comes
if
ever
through
library,
itself
and
I
think
it
has
like
a
very
proper
a
place.
J
To
exist
in
in
our
interview,
tooling,
as
it
being
said
like
what
Sergey
was
presenting
here,
handing
not
not
being
required
to
write
a
manager
code
for
that,
and
just
a
stain
missing
a
sushar
code
only
would
be
just
next
level
of
safety
and
reliability.
And
what
implemented
both
solutions.
But
we've
been
talking
about
getting
like
solving
hard
problems
such
as
like
I,
was
growing
up
and
Jen
optimizations
and
such
it
would
be
best.
J
You
know
like
if
it's
handled
as
a
part
of
a
choral
library
and
solution
which
says
instrument
radius
doesn't
need
to
know
about
like
all
this
more
details,
hopefully
that
only
few
people
on
the
planet
need
to
know,
and
you
need
to
know
about
that.
The
rest
can
just
stays
in
the
management
center
space.
B
B
Reggie
is
the
basic
stuff
you
have
to
provide
or
read
these
integrations
out
of
the
box.
You
know
because
I
think,
from
from
the
perspective
that
I'm
coming,
the
thing
that
we
want
to
be
able
to
offer
is
for
people
that
have
some
legacy
code
to
be
able
to
see
distributed,
tracing
and
useful
metrics,
even
without
having
the
trouble
to
remain
their
code.
I
think.
B
In
the
end,
people
should
instrument
their
code
because
they
get
much
more
variable
and
targeted
information,
but
sometimes
it's
hard
to
motivate
people
to
do
that
extra
effort
before
they
can
see
how
it's
gonna
look
like
the
information
you
know
so
having
some
kind
of
a
extra
mentation
for
this
popular
libraries
frameworks.
I
think
makes
much
more
like
for
people
to
jumping
into
the
instrumentation
and
start
to
use
metrics
disability
tracing
whatever
we
we,
we
think
it's
useful.
You
know
that.
G
Yeah,
absolutely
absolutely
that's
that's
what
we
run
into
all
the
time
at
New,
Relic,
there's
I
have
to
say
really,
probably
the
vast
majority
of
customers
that
I
that
I
speak
with
today
are
ones
that
don't
really
want
to
touch
their
code
and
I
do
see
that
changing
over
time
as
you've
suggested,
but
yeah
I
think
it,
and
my
impression
is
that
it's
just
gonna
take
a
while
for
the
industry
to
kind
of
a
doc.
Those
patterns
and
practices.
E
To
decide
how
far
back
you
want
to
go,
because
it
may
be
much
easier
to
do
zero,
Cola,
for.net
core,
and
here
we
can
provide
rich
functionality
with
minimal
investment.
Well,
if
we
really
want
to
go
into
the
desktop
version,
it'll
separate
solution
that
we
need
to
provide-
or
maybe
it's
a
separate
like
more
involved
core
that
needs
to
be
developed
and
we
can
even
like
I
mean.
E
Ultimately,
we
have
couple
solutions
like
we
has
a
data
dog
agent,
and
we
have
here
our
instrumentation
engine
and
intercept
and
difference
is
the
data
doc
agent
already
works?
So
you
only
need
to
invest
a
little
bit
to
reroute
some
callbacks
into
open
today.
Meters,
decay
and
you
ultimately
done
right
so
solution,
maybe
use
that
data
doc
as
a
booster
for
older
applications
and
I
use
like
intercept
in
termination
engine
approach
for
more
modern
application.
E
B
Yeah
I
I
think
we
we
should
perhaps
try
to
establish
kind
of
the
goals,
and
the
criteria
is
that
we
could
use
to
to
make
this
decision
in.
In
conjunction,
like
everybody,
come
trying
to
come
to
our
consensus
what's
best
and
the
best
there
will
be
a
lot
of
questions
that
are
hard
about
kind
of
who
can
contribute
what
resources
to
true
watts
and
where
things
should
live,
but
I
think
I
think
the
next
step
for
should
be
kind
of.
B
We
define
the
goals,
do
some
between
the
community
here
and
decide
kind
of
what
are
the
top
priorities
that
are
going
to
guide
our
choice
and
put
some
criterion,
try
to
decide
on
top
of
them.
Iii
from
my
side
phone
on
the
short
term,
I'm
I
went
to
look
more
at
the
instrumentation
engine
and
try
the
samples
try
to
do
something.
B
Perhaps
if
I
have
time,
I
will
try
to
do
some
instrumentation
that
I
have
already
data
dog,
try
to
do
it
using
the
interception
engine
and
try
to
compare
those
to
see
what
what
for
my
perspect
you'll
be
kind
of
the
best
solution
right,
but
I
think
we
we
needed
to
come
up
with
I
can
try
to
to
put
some
very
short,
not
a
document,
but
perhaps
on
that
issue
on
github.
Try
to
propose
some
criterias
to
be
kind
of
what
should
guide
our
choice
decision
here.
I.
I
Think
it
makes
sense,
Paula
and
I
would
love
to
join.
You
be
the
investigations
of
data
dog
and
can
help
you
accelerate
and
intercept
like
this.
We
can
also
borrow
a
lot
from
terrible
John,
open,
telemetry
agent
right
now
he's
very
much
mature
and
we
can
vote
for
them
how
they
achieve
this
state
and
pass
it
from
their.
E
Okay,
so
let's
start
a
discussion
on
github
issue:
I
think
we
exhausted
list
of
contenders
for
code
injection
logic,
I,
don't
know.
If
anybody
knows
somebody
some
time
ago.
That
means
investigation.
We
can
do
that.
Otherwise,
you
can
start
understanding
how,
like
maybe
estimate
some
investments
and
then
who
wants
to
invest
in
which
part
and
then
decide
based
on
that.
Maybe
off
I
know.
Maybe
next
time
we'll
have
more
information.
E
B
C
C
Yes,
I
think
that's
the
update
just
for
like
people
so
we're
not
the
we
decided
to
switch
meeting
times
from
11
a.m.
to
alternate
between
learn
a.m.
and
4:00
p.m.
so
Pacific
time.
So
this
week
we
met
at
4
o'clock
so
next
week
it
will
be
11
o'clock
and
then
for
approve
its
already
updated
in
the
community
just
in
case.