►
From YouTube: .NET Design Review: System.Diagnostics.Activity
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
B
Yeah,
I
can
give
some
quick
overview
about
what
we're
trying
to
do
here.
So
basically
we
have
the
system
diagnostic
CBI's
today,
which
is
providing
some
api's
to
how
to
publish
dressing
information
and
how
to
listen
to
this
dressing,
information
that
published
and
collected
and
so
on,
and
in
same
time
we
got
the
oven,
telemetry
project
dissolving
source,
which
is
defining
suspects
for
how
to
do
tracing
and
exporting
is
a
tracing
data
and
so
on.
This
is
open
sources.
B
The
finance
the
specification
for
how
to
do
that
and
it
is
going
to
be-
or
it's
really
I
mean
implemented
with
in
different
language
like
Java
go
and,
of
course,
I
mean
dotnet
is
implementing
it
and
so
open
telemetry
is,
is
opening
the
door
for
supporting
more
scenarios
that
we
don't
currently
support
in
our
system,
diagnostic
CBI
and
the
goal
here
we
have
listed
down.
If
you
go
down
a
little
bit,
we
listed
some
goals
that
we
need
to
achieve
by
adding
zcb
eyes.
B
So
let's
go
more
more
yeah
yeah,
more
yeah,
it
is
the
goals.
So
if
we
go
through
the
goals,
I
mean
the
number
three
is.
The
main
goal
from
my
point
of
view
is:
have
activity.
Activity
is
the
main
class
in
system
Diagnostics,
which
is
used
to
to
to
add
to
publish
tracing
data
in
general,
so
activity
needs
API.
B
Representation
of
open
telemetry
span
concepts,
so
we
need
spam
is
a
similar,
similar
class
in
open
telemetry
is
that
is
doing
the
same
as
activity
in
system
Diagnostics,
so
we
need
to
close
the
gap
and
support
all
all
scenarios
that
span
is
currently
supporting
it.
This
is
one
of
the
goals,
and
the
other
thing
is
like
we
have
we
are
already
discussing.
B
Now
is
a
if
it
is
possible
we
can
get
rid
of
the
span
in
the
oven,
telemetry,
fully
get
rid
of
it
and
her
just
as
activity
is
the
main
main
class
that
can
be
used
even
in
open
telemetry,
to
publish
tracing
data.
This
is
one
of
the
goals
and
other
goods
is
today.
We
have
some
limitation
with
activities,
for
example,
about,
like
you
know,
if
you
want
to
listen
to
the
activity,
you
have
to
listen
to
a
specific,
using
diagnostic
source
or
diagnostic
listener.
B
You
have
to
say
to
listen
to
specific
activity
means
or
something
like
that.
I
mean
like
it's
restricted
to
to
know
the
names
that
you
are
going
to
listen
to,
so
you
don't
have
a
way
to
listen
to
any
activities
or
all
activities
that
you
want
to.
So
this
is
one
of
the
scenarios
we
need
to
to
support.
Also
yeah,
of
course,
I
mean
second
goal
also
is
to
have
a
way
to
filter
what
to
listen
to
and
what
you
don't.
You
don't
want
to
listen
to
for
executives
when
publishing
any
data.
B
Good
number,
for
also
is,
is
important,
which
is
the
ABI
usability
so
today,
the
way
that
you
can
you
can
use
activities
has
some
button
how
to
use
it,
and
this
pattern,
actually
is,
is
a
little
bit.
Not
not
neat
I
mean
to
to
use,
and
we
are
trying
to
simplify
the
button
to
be
very
simple,
I.
Think
I
think
we
have
some
cool
example.
For
this
how-to,
if
you
go
down
a
little
bit,
maybe
it's
we
have
the
code
Sam,
but
I.
Don't
remember:
yeah
go
down
more
MORE
yeah
yeah
more!
B
B
Tours
and
passing
the
names
that
they
are
interested
to
to
use
and
first
I
mean,
like
you
know,
because
the
library
code
or
the
app
code
I
mean
like
they
trying
not
to
create
activity.
If
nobody
is
listening
to
it,
so
there
is
no
point
to
create
it,
so
what
they
do
is
they
try
to
avoid
creating
activities
by
checking
first
about,
like
you
know,
if
the
listener
is
enable
anybody
listening
and
if
it
is
yes
so
at
go
and
check
another,
do
another
check
watch
this
activity
listener.
B
It
is
enabled
and
check
if,
as
your
core
HTTP
request,
it's
somebody
listening
to
this
and
if
somebody's
listening,
so
at
that
time
only
I
mean
like
you,
go
and
create
the
activity
and
try
to
block
the
stop.
But
if
nobody
is
listening,
so
there
is
no
going
to
create
the
activity
at
all
and
later
I
mean
because
after
you
you
you
do,
that
I
mean
either
creates
activity
or
not
you
later
in
the
code.
B
B
Yeah,
this
is
yeah,
so
obviously
our
screen.
This
is
how
we
are
trying
to
simplify.
No
no
go
up,
go
up
a
little
bit
yeah
the
top
screen
yeah
in
the
top
screen.
This
is
how
we
are
trying
to
simplify
this
a
better
now.
So,
basically,
we
have
something
called
activity
source.
We
are
going
to
talk
about
this
later
and
in
more
details.
This
activity
source
is
a
way
I
mean
you
create
I
mean
usually
the
library
will
create
just
one
instance
of
it
and
the
other
means
they
can
use
it
to
create
activity.
B
So
we
introduced
something
called
start
activity
in
the
activity
source.
This
is
the
message
that
you,
you,
create
activity
with
you'll
notice
that
this
missile
is
returning
nullable
string,
not
novel
object
activity
object
is
not
returning
just
non
malleable,
which
is
mean
like
you
know.
This
method
will
do
this
work
for
you,
I
mean
like
it
go
and
try
to
find.
B
If
anybody
listening
or
not
or
something
exists,
if
nobody
listening
so
to
return
you
or
not,
if
somebody
is
listening
and
interested
to
create
activity
it
would
it
will,
it
will
create
user
activity
and
also
we
made
activity
as
disposable.
So
it's
somebody
created
activity
and
you
inside
using
using
block,
so
it
will
be
automatically
get
disposed
disposed
means
like
we
are
stopping
the
activity.
The
activity
object
tons
of
time
so.
D
I
got
a
question:
it
seems
like
you,
you're,
trying
to
optimize
allocations
by
returning
null
if
activity
is
not
started.
Right,
I
end
some
work
that
this
is
happening
inside,
but
the
start
activity
overloads.
They
take
a
lot
of
parameters
that
are
quite
complex
and
it
seems
like
I
have
to,
for
example,
create
or
the
dictionaries
with
Tad's
before
I
can
call
start
no.
B
I
mean
this
is
optional
parameters
for
start
activity.
We
we
have
a
couple
of
overloads
that
there
is
a
simple
one,
I
mean
like,
which
is
one
which
is
stick
like
just
as
the
activity
name
and
what
we
call
it
activity
kind.
This
is
simple,
simplest
one,
but
if
you
want
to
have
more
control,
you
can
pass
more
parameters
with
the
overload
the
other
overloads
and,
in
the
other
overloads
it
has
optional.
D
But
I'm
saying,
if
my
usage
scenario
is
such
that
I
want
to
pass
those
additional
parameters,
I
have
to
kind
of
create
them
before
I
call
an
art
method,
that's
right,
which
means
I'm.
Gonna
spend
a
lot
of
basically
there's
gonna
be
some
cost,
and
then
your
activity
returns
null
and
I'm.
Like
yes,
inactivity.
B
D
I,
don't
want
to
create
this
dictionaries.
You
recommend
that
I
go
back
to
the
previous
pattern.
That
you
said
is
not
as
usable.
Yes
is
this
the
best
we
could
do
because
one
additional
thing
I'm
thinking
we
could
do.
It
is
use
a
callback
where,
like
you
know,
we
call
you
and
say:
yes,
we
have
an
activity,
go
fill
in
the
I,
don't
know
if
it's
actually
gonna
hurt
I
mean
it
could
be.
You
know
a
wash
meaning.
You
know.
There's
ability,
negatives
of
having
a
callback
may
may
not
be
something
that
we
want.
E
Yeah
I
mean
I,
know
what
you,
what
you
mean,
Christophe
and
I
did
at
one
point,
go
to
type
something
that
had
a
callback
like
that
I
think
I
needed
to
do
a
little
bit
of
work
to
make
sure
I.
Wasn't
this
mean
you're,
potentially
wind
up
doing
an
allocation
for
the
delegate
that
you
pass
as
the
callback,
but
if
you're
a
little
bit
careful
you
can
avoid
that
too,
but
it
seemed
like
just
doing
is
enable
check.
E
Well,
it
wasn't
that
much
more
more
verbose
than
sort
of
setting
up
the
callback
and
it
seems
pretty
straightforward
in
terms
of
understanding.
What's
happening,
you're
gonna,
guess
it
it
does
start
to
go
back.
It
doesn't
go
all
the
way
back
to
sort
of
the
complexity
of
the
previous
code,
but
it
does
sort
of
increment
back
in
that
direction.
E
One
of
the
things
that
maybe
made
me
feel
a
little
bit
better
about
that
is
presumably
the
only
people
that
are
going
to
be
calling
with
the
large
number
of
parameter
overloads
are
probably
folks
they're.
The
ingestion
point
for
activities
like
where
it's
first
coming
in
from
an
external
source
and
those
folks
are
probably
pretty
rare
as
software
components
go
like
Kestrel-
is
one
example.
If
someone
were
to
make
some
sort
of
you
know,
you
know
G
RPC,
server
or
other
like
custom
protocol
server.
E
E
B
Yeah,
those
are
a
good
example
in
the
bottom
of
the
screen
here
is,
is
just
like
the
way
how
to
create
a
listener
using
the
activity
source
to
listen
to
the
activities
and
it
it
will
have
like
five
callbacks
I
mean
just
handle
different
situations.
We
will
go
through
this
emulator,
so
we
can
start
looking
at
the
API
as
if,
if
anybody
have
any
question
before
you
go,
there.
D
Actually,
I
have
one
more
question.
So
I,
like
your
fifth
point,
saying
that
you
one
of
the
goals
is
to
be
backwards
compatible
with.
You
know
the
pattern
that
we
established
a
year
ago
or
something
so
in
our
code
in
our
SDK,
when
we
we
basically
wrap
calls
into
the
networking
start
with
you
know,
creating
your
activity
and
kind
of
something
that
we
can
do
with
the
ideas
that
you
just
showed.
The
only
difference
that
I'm
seeing
is
that
we
also
catch
exceptions
and
when
an
exception
propagates,
we
call
scope
failed
and
we
pass
exception.
D
E
But
that
is
what
we
would
want,
because
it
looks
highly
focused
on
G
RPC,
error
codes
and-
and
there
was
no,
there
was
no
good
mapping
for
an
exception
or
any
other
kind
of
error
code
that
you
might
have
that
wasn't
specifically
in
G
RPC
error
code
and
so
the
goal
there
was
to
talk
of
it
with
the
open,
telemetry
community
more
broadly
and
see
if
we
could
find
some
more
generic
error
representation.
That
would
I
mean
not
only
be
amenable
to
say,
dotnet
exceptions,
but
maybe
to
Java
exceptions
or
what
other
languages
are
doing.
E
But
in
lieu
of
have
it
like.
We
haven't
yet
sort
of
had
a
proper
discussion
around
that,
and
so
we
don't
have
any
API.
It's
sort
of
a
strongly
typed
reference
nation
of
error
on
the
activity
yet,
and
so
without
sort
of
a
well-defined
notion
of
how
you
should
attach
the
error
to
the
activity.
We
have
also
avoided
trying
to
create
any
API
syntactic
sugar.
That
would
sort
of
run
your
run
your
scope
and
then
attach
an
error.
E
E
You
wanted
to
run
if
your
delegate
and
we
basically
run
that
inside
of
a
try-catch
for
you
and
fit
through,
we
would
assign
the
exception,
or
some
self
class
an
exception
to
the
activity,
but
effectively
that
whole
thing
got
just
postponed,
trying
to
figure
out
what
open
telemetry
specification
for
error
would
be,
and
then
how
that
would
surface
on
this
new
API.
So.
D
I
assumed
that
today,
when
we
call
called
scope
that
failed,
I
can
even
point
to
people
if
people
want
to
see
our
source
code,
I
could
eat
a
child
chatroom,
but
we
call
because
you
know
in
the
in
the
catch.
You
know
we
call
scope
that
failed
and
I
assume
scope.
The
scope
that
failed
is
something
where
we
just
add
a
bunch
of
tags
and
log.
You
know
something
that
is
not
specifically
an
egg.
You
know
an
exception.
Just
we
look
at
an
event
right,
I
assumed
that
we
would
keep.
D
E
I
think
so
I
mean
assuming
that
you
will
continue
to
value
the
back
compartment.
What
you
currently
do
it,
because
what
you're
currently
doing
is
basically
a
a
convention
that
that
your
team
has
has
adopted
I,
don't
know,
maybe
someone
else
has
adopted
it
as
well,
that
I'm
not
familiar
with
it,
but
definitely
at
the
at
the
BC
L
layer.
There's
not
like
a
solid
convention
that
all
users
of
activity
work
towards
men.
E
D
C
C
D
B
I
I,
just
I,
want
to
add.
Also
what
like
we
are
proposing.
A
new
to
epi
is
I
mean
in
sins
activities,
which
is
called
set,
custom
property
and
get
custom
property.
This
is
to
attach
any
any
other
objects
to
the
activity
object,
but
it's
not
strongly
tied
as
as
now
mentioned,
so
this
is
kind
of
also
can
be
used
to
attach,
like
the
exception
or
something
to
the
activity,
just
pointing
to
that.
H
E
So,
though
I
mean
so,
the
listener
gets
multiple
callbacks,
they
get,
they
get
a
callback
initially
for
sampling,
they
get
started
and
they
get
stopped,
and
so
the
current
assumption
is
that
only
in
stopped
at
the
end.
You
know
which
corresponds
to
the
disposed
of
that.
Using
should
the
listener
assume
they're
all
having
stags
have
been
populated.
E
However
I
there
is
an
email
discussion
going
on
right
now
with
someone
who
had
said
well,
I
want
to
get
the
tags
on
the
started,
callback
and
so
I
basically
asked
them
and
I've
yet
to
receive
a
response,
but
hopefully
we
will
soon.
I
was
just
sort
of
like
well.
Why?
Why
does
it
matter
that
you
get
these
eggs
onto
started?
B
B
B
B
J
E
E
B
J
B
E
E
B
D
B
Put
it
under
system
Diagnostics,
because
activity
class
itself
is
under
system
Diagnostics.
This
is
the
only
reason.
I
put
it
here.
The
grant
activities
using
I
mean
like
but
I
don't
have
any
strong
position.
I
mean
like
if
you
think
like
we
should
have
this
site
soft
namespace
or
something
like
this
yeah.
It
seems.
D
B
D
D
B
Okay,
so
going
back
to
activity
context
as
I
mention
about
like
it.
It
just
has
four
four
properties:
I
mean
describing
the
context
and
it's
defined
the
moon,
like
we
already
have
the
activity,
trees,
ID
and
activity
span
ID
this
already
defined
before
I
mean
this
is
not
new
types,
which
is
we're
ready
using
it,
and
this
activity
trace
flag.
Also
me
so
any
question
regarding
those.
N
C
D
B
D
B
Next
is
activity
event.
Also,
this
is
also
is
coming
from
the
oven,
telemetry
aspects,
it's
just
defining
event,
event
have
like
name,
timestamp
and
and
optionally.
It
can
have
some
attributes
like
key
value.
Pairs
I
mean
like
from
string
to
objects,
so
yeah
I
mean
just
we
adding
this
also
because
of
intimately
supporting
it.
N
Can
I
ask
a
question
about
this
particular
class?
Yes,
actually
I'm
from
eye
surgery
and
we
are
trying
to
use
open
telemetry
actively
in
our
arc
and
then
it's
something
that's
similar
to
logs,
so
that
can
be
calorie
correlated
with
activities,
always
J
response.
So
what?
What
is
the
purpose
of
this
activity
or
event
or
Spang
event.
B
E
Yeah
I
mean
from
what
I
saw
in
the
open,
telemetry
specification,
I.
Think
I,
don't
know
if
this
is
the
canonical
use,
but
this
sounded
like
at
least
one
of
the
intended
uses
was
for
gr
PC
streaming,
where
you
have
packets
of
data
coming
in
periodically,
but
all
those
packets
together
sort
of
represent
one
request.
It's
just
not
being
delivered
in
a
single
sample
message,
and
so
they
would
long
events
every
time
a
new
packet
would
come
in.
K
K
But
if
you
have
another
stream,
where
you
want
to
log
something
regardless
of
whether
people
simple
the
trades
are
not,
then
it'll
be
a
separate
thing
and
I
think
Internet
in
general,
we
want
to
pursue
the
ilogger
path,
so
both
of
those
are
the
ways
that
you
can
attach
specific
information
and
click
that
that
they
have
different
purpose
and
you
need
to
think
about,
like
sampling
and
and
whenever
you
want
to
enable
trace
or
not.
Oh.
N
F
N
H
E
C
E
You've
all
Tareq's
doing
that
with
me
as
well.
If
you
want
to
quickly
scroll
down
to
the
activity
class
API
just
to
demonstrate
more
exacting,
okay,
there,
it
is
so
you
see,
there's
a
new
API,
there
called
add
event
and
there's
a
property
that
is
an
enumerable
of
all
events
that
you've
added
to
the
activity,
so
that
that's
just
the
list
of
events
that
have
been
logged
on
that
activity,
so
that
that's
the
that's
where
activity
then
gets
used
is
just
the
strongly
typed
item
that
goes
into
that
list.
I.
E
B
B
So
so
the
link
is
just
try
I
mean
to
add
the
link
to
other
trace
in
context
to
the
current
activity.
So
the
link
is
just
simply
it
has.
It
has
activity
context,
which
is
you
can
link
to
the
other,
this
activity,
context
to
the
specific
activity
and
also
it
has
optional
attributes,
which
is
key
value
pairs
I
mean
you
can
add
to
this
to
this
link.
D
M
G
E
B
Okay,
Nick
as
the
activity
data
request.
This
is
its
it's
our
way.
I
mean
like
it's
a
announced
that
it
defines
how
you
want
to
create
the
activity.
So
this
this.
Actually,
this
the
value
of
this
enum
is
get
returned
it
from
from
the
listener
cool
back.
So
when,
when
we
try
I
mean
we
know
calling
activity
source
start
activity,
it
would
call
the
listener,
and
the
listener
will
return.
This
enum
to
us
and
I
know
is
first
value
is
not
means
that
is
not
interested.
B
I
mean
the
listeners
not
interested
to
create
the
activity
at
all,
and
second,
one
is
propagation
data.
This
is
telling
like
I
need
to
create
the
activity,
but
the
purpose
of
this
activity
is
just
for
propagation,
so
it
doesn't
have
to
carry
data
like
tags
or
events
or
whatever,
and
third
third
value
is
all
data
means
that
need
to
create
the
activity
and
I
need
to
carry
I
mean
like
to
brilliant
on
dataset
and
last
one
is
is
just
for
for
having
like
create
activity
having
full
data
on
it,
and
this
will
get
propagated
yeah.
B
E
E
I
mean
that
a
quick
history
there
is
so
w3c
the
specification
defined
straight,
the
trace
ID,
it
has
personage,
take
a
trace
context.
It
defines
a
bit
and
that
bit
indicates
whether
you
expect
to
sample
texts
or
not,
and
this
bit
flows
across
the
wire
and
everybody
sees
it.
The
ideas
of
someone
sets
the
bit
high.
Then
all
the
listeners
downstream
should
log
in
that
bit.
E
In
2019,
when
the
runtime
team
implemented,
the
specification
was
called
the
recorded
bit
and
then
sometime
very
shortly
before
the
specification
got
ratified,
or
whatever
confirmed
they
changed
the
name
of
the
bit
to
be
sampling
bit.
Unfortunately,
at
that
point
the
runtime
had
already
implemented,
as
recorded
so
the
name
for
that
bit
in
our
API
is
called
recorded
and
then,
unfortunately,
to
make
matters
worse,
open
telemetry
went
and
they
reused
the
name
recorded
to
mean
something
else,
because
they
had
reading
a
bit
to
be
sent
leave
it
all.
E
That
said,
we
decided
to
try
and
keep
the
naming
consistent
within
our
own
API
as
in
dot
method
sort
of
self-consistent,
but
it
does
not
wind
up
being
the
existing
specification.
Our
other
alternative
would
be.
We
could
be
consistent
with
the
specification
for
naming
here
which
would
make
our
API
internally
inconsistent.
E
B
A
A
A
Mean
this
is
my
beer
more
like
a
spec
question,
but
it
seems
like
I
can
see
this
deteriorating
over
time
into
a
bit
vector,
because
if
it's
because
it
seems
like
it's
already
like
combining
multiple
things
and
then,
if
they
add
more
things
in
the
future,
then
you
basically
end
up
with
an
e
number
of
all
popular.
You
know
all
combinations,
which
seems
like
a
bad
idea
in
the
long
run.
E
J
E
J
J
J
E
At
the
moment,
each
if
you
modelled
it
as
a
three
bit
vector,
though
the
only
valid
states
are
sort
of
where
all
the
ones
are
to
the
left
and
all
the
zeros
are
to
the
right
like
you
can
decide
how
many
places
are
filled
with
ones.
So
you
can,
you
know
you
can
either
have
four
zeros
or
you
can
have
a
one
or
sorry,
three
zeros
or
one
and
two
zeros
or
two
ones
and
zeros
all
ones.
E
A
I
mean
I
kind
of
agree
with
what
Jeremy
said
regarding
like
combinations
being
did
you
know
that
they
all
should
be
legal,
but
there's
a
trade-off
right.
If
you
have
12
different
items
and
like
certain
combinations
of
items
are
invalid,
it's
probably
easier
to
model
as
as
a
bitmask
and
then
just
validate.
O
O
E
A
E
Yeah
I
mean
certainly
so
far
everything
they've
done
that
doesn't
have
combinatorial
expansion,
because
it's
each
thing
is
just
always
strictly
a
superset
of
the
thing
that
came
before
and
it's
actually
illegal
to
sort
of,
say,
I
want
the
new
dig
up
and
I
don't
want
some
of
the
old
biga
right
I
mean
it's
not
to
say
that
it
wouldn't
maybe
break
that
pattern
at
some
point,
but
it
made
also
currently
model
this
thing
asn't.
You
know
not
as
a
as
a
bit
vector
in
the
open,
telemetry
spec,
okay,.
B
Okay,
yeah
next
is
their
activity
source,
and
this
is
one
of
the
most
important
types
when
introducing
here,
and
the
purpose
of
this
type
is
the
new
way
to
create
and
start
activity
with
the
mechanism
of
like
trying
to
avoid
creating
the
activity.
If
it
nobody
is
listening.
Also,
this
is
activity
sources,
a
way,
also
to
add
a
listener.
If
you
want
to
listen
to
those
activities,
so
you.
B
B
Version
is
just
the
version
of
this
could
want,
so
the
version
is
requested
because
there
is
possibility.
I
mean
like
to
collect
to
collect
tracing
information
from
same
different
version
of
the
same
component.
So
this
is
why
we
got
a
version
zero.
We
originally
proposed
the
vision
as
a
version
class
that
we
had,
but
it
was
requested
later
to
be
a
string
to
have
more
flexibility
to
what
like
to
specify
the
version.
The
way
that
the
consumer
will
like
set.
P
E
F
D
B
E
Can
we
scroll
down
to
the
actual
API,
but
that's
the
one
I'm
looking
at
go
there
we
go
right,
so
one
I
would
say
one
argument
for
not
doing
that.
Is
that
these
well
specifically
where
so
those
two
the
two
funks
right
now
that
have
the
long
list
of
parameters
attached
to
them,
so
those
folks
are
called
as
part
of
the
sampling
algorithm,
which
puts
them
on
the
they're
on
the
sort
of
hottest
path.
E
In
all
of
this
code,
they're
gonna
get
called
every
time
you
call
activity,
you
got,
there's
an
activity
source
start
activity
and
even
if
you're
sampling,
everything
out
saying
yeah
I
want
to
listen
to
any
of
this
stuff.
You're
still
gonna
make
that
call
just
find
out.
They
don't
want
to
listen
to
any
of
this
stuff,
and
so
so
far
we've
been
taking
some
effort
going
out
of
our
way
to
make
that
path.
E
You
know,
have
this
view
out,
patience
in
it
as
possible.
So
if
we
made
this
thing
use
and
effect
art,
we
would
either
have
to
allocate
that
event.
Art
object.
Each
time
we
make
the
call-
or
we
have
to
make
like
a
thread-
static,
cache
of
them
and
you'd
have
to
do
a
you
know
like
a
lookup
to
get
your
thread
static,
argh
to
invoke
it.
Both
of
those
would
have
some
performance
overhead
well,.
D
D
They
don't
the
the
event.
Arts
are
thinking
socket,
API
Steve
can
can
talk
to
this
I
think
they
don't
inherit
from
event
arts.
For
this
reason-
and
they
are
it's
just
basically
a
struct-
it's
a
property
bag.
I
know
it
would
be
large
but
kind
of
it's
a
lot
of
now.
You
just
have
a
func
with
lots
of
parameters.
They
have
to
be
passed
anyway.
So.
E
C
D
E
E
D
C
A
D
A
Know
seriously
so
like
I
would,
even
even
if
we
pack
it
together,
I,
probably
still
wouldn't
use
a
raw
farm,
because
I
mean,
if
you
just
look
at
the
signature
on
the
screen,
people
had
to
kind
of
find
creative
formatting
ways
to
make
this
not
beatable
like
garbage
I
would
probably
just
still
make
it
a
strongly
typed
delegate
that
you
can
actually
name
and
document,
because
then
you
can
take
it
as
an
ordinary
type.
You
don't
have
to
have
these
nested
generics
I
think.
That's,
that's
probably
better
still,.
E
Yeah
yeah
I
mean
no.
No
objection
to
that.
For
me,
so
I
mean
our
just
to
make
sure
it's
I
mean
I,
think
there's
a
few
different
things
that
have
been
thrown
out.
So
what
one
is
sort
of
collapsing
all
of
these
parameters
into
a
and
I'm
I'm
guessing
there's
two
different
variations
of
that
one
would
be.
E
We
cook,
we
sort
of
collapse,
all
the
input
parameters
into
a
struct,
but
leave
activity,
data
requests
the
return
value
separate
or
there's
another
variation
where
you
put
that
into
the
struct
I
mean
I
would
probably
favor
where
we
don't
collapse.
Activity
data
into
the
struct
activity,
data
requests
into
the
struct,
and
then
there
is
a
second
one
to
say:
let's
just
have
a
strongly
typed
delegate,
so
we're
not
using
funk
and
then
I
don't
know
if
at
some
point
it
was
a
proposal,
but
you
actually
make
this
BB
event
pattern.
Q
D
B
B
P
B
D
Said
that
I
discussing
before
the
main
scenario
will
be
to
call
startactivity
with
just
the
name?
Yes,
so
if
we
make
it
into
a
strike
that
we
would
have
to
add,
overloads
I'm,
not
sure
it's
worth
playing
around
with
it
with
this
idea,
but
I
think
it
would
be
totally
acceptable
for
the
listener
to
use
this
chart.
But
for
startactivity
to
just
have
simple
overloads
or
you
know,
default
parameters,
as
you
have
right
now,.
B
N
Sounds
good
yeah
I
also
have
a
question
here
about
the
activity
search,
so
it
is
really
similar
to
the
tracer
from
open
telemetry
and
in
tracer
it's
like
a
possible
to
start
a
new
span.
We
should
not
be
an
active
span,
but
here
I
guess
we
like
a
bystander
in
the
new
activity
we
are.
We
are
studying
the
nested
activity
like
we
are
creating
new
activity
in
the
in
the
current
context.
Yes,.
K
N
Yeah,
but
if
I
just
want
to
say
to
stir
a
span
or
activity
and
like
to
do
something
on
it
and
like
a
mean
D
telemetry
from
it,
but
not
to
have
it
as
a
like
an
active
activity
in
this
current
context,
I
mean
an
activity
we
have
current
property
and
in
that
is
in
activity
class.
But
in
open
geometry,
it
is
current
span,
property,
isn't
in
tracer
class.
There's
this
difference
and
it
can
be
confusing.
What
is
he.
E
N
Eight
yeah
yeah
there
isn't
like
a
different
different
things,
though
so
the
first
one
is
that
when
we
using
activity
source
to
create
an
activity,
we're
basically
creating
the
new
active
activity
right,
it
will
be
accessible.
Do
we
activity
at
current
yeah,
but
this
is
a
difference
from
the
open,
telemetry
concept
when
we
have
something
like
this
something
separated
from
from
spam
term
activity
and
these
currents
can
be
accessible
not
by
Spanish
self,
but
by
the
tracer.
So
I
mean
this.
E
So
I
think
so
I
mean
I'm,
certainly
open
to
having
some
sort
of
API
that
creates
an
unstarted
activity,
but
I
feel
like.
We
probably
need
to
dive
into
that
off
line.
To
make
sure
we
understand
the
scenario
that
that's
supporting
a
little
bit
better
and
figure
out.
No,
because
how
important
it
is,
how
it
needs
to.
B
B
E
What
I
want
to
find
out
like
how
does
it
interact
with
sampling,
like
the
the
constructor
that
we
have
right
now,
doesn't
really
interact
with
sampling,
so
I?
But
I
don't
understand
yet
whether
or
not
this
scenario
being
proposed,
where
you
create
unstarted
activities
on
the
tracer,
they
interact
and
sampling
some
way,
which
is
part
of
why
I'm
suggesting
is
probably
better
that
we
would
take
it
offline,
because
I
can
be
able
to
detail
and
get
into
here.
E
N
E
And
then
the
other
one
you
raised
I
think
is
just
a
safe
there's,
a
pre-existing
static
property
on
activity
which
is
activity
current
and
you're,
saying
open,
telemetry
exposes
their
version
of
activity,
source
is
called
tracer
and
that
they
expose
tracer
that
current
and
so
then
you're
just
saying
it's
yeah.
If
they.
E
I
guess
I'd
say
my
predilection
is
to
sort
of
keep
the
API.
We've
already
got
that
activity,
not
current
and
just
sort
of
acknowledge
that
that
is
the
difference
between
what
the
spec
suggests
versus
what
net
implements,
but
I
mean
I.
Think
if
people
gave
us
a
lot
of
feedback
that
that
was
really
confusing.
E
It
doesn't
seem
too
problematic
to
me
that
you
would
add
a
property
to
activity
source
whose
only
purpose
is
just
to
go:
call
activity,
dot,
current
and
return.
You
the
same
value
that
activity
dot
current
would
have
returned,
except
now
it's
a
property
of
activity
source
instead.
My
my
hunch
here
was
that
we're
not
gonna
have
a
ton
of
developers
going
to
look
at
the
open,
telemetry
specification
like
as
written
as
a
document
and
sort
of
say,
hey
I
thought
it
would
work
this
way.
E
But
then
I
went
to
go
work
at
your
API
and
it
didn't
work
that
way.
I.
Imagine
the
folks
doing
design
perfect
ulema
tree
probably
go
on
experience.
Looking
at
that
spec,
but
I'm
just
biologist
that
most
developers
that
use
this
API
will
will
not
be
doing
much
so
they
helped
Wesley
I
just
finish
it
with
which
to
be
confused.
B
I
want
to
point
out
also
a
lot
like
there
is
discussion
now
to
get
rid
of
spam
fully
to
get
rid
of
it
in
the
oven,
tonometry
site,
so
probably
I
mean
like
we
will
not
have
a
spans
here
in
the
album
telemetry
and
regarding
regarding
that
tracing
I
mean,
like
you
know,
the
tracer
I
mean
I'm,
not
I'm,
not
saying
this
would
be
a
big
problem.
Even
like
you
know,
in
autumn
telemetry
you
can,
you
can
still
implement
the
tracer
dot
current
span
or
current
activity,
which
is
we'll
just
call
activity
to
current
onion.
I
A
A
A
E
A
B
A
A
I
mean
it's
I
mean
like
the
thing
is
it's
an
argument
that
I
have
to
pass
in
right?
If
I
call
activity,
sores,
don't
start
activity,
then
well,
I
have
to
manufacture
this
thing
somehow
right
and
like
if
I
said,
I
knew
off
key
value.
Pair
I
can't
help
myself,
but
think
of
my
dictionary
or
a
dictionary
or
I
didn't
I'm,
probably
not
the
only
one
yeah.
E
E
Ahead
and
so
part
part
of
me
is
suspicious
that
even
if
the
suspect
says
the
border
should
be
preserved,
I
I
can't
all
pant
think
of
why
it
would
matter
for
the
order
to
be
preserved.
I
mean
it's
not
I,
don't
think,
there's
a
scenario
where
you
specifying
the
same
like
the
same
key
and
then
a
different
value,
so
yeah
I
don't
know.
A
K
E
K
K
B
Okay
for
activities,
the
first
thing
you'll
notice
about
we
added
I,
disposable
interface
to
it,
as
I
mentioned
early
about
like
when
disposing
the
activity.
If
it
is
started,
source
topic-
this
is
what
the
dispose
is
going
to
do.
This
is
just
to
simplify
the
pattern
that
writing
the
code
on
using
activity.
B
E
C
Also,
the
first
activity
in
the
chain
that
actually
disposes
our
stops
would
clean
up
all
its
child
activities
that
didn't
dispose
themselves.
So
if
you
didn't
this,
if
you
didn't
dispose
your
activity,
but
somebody
dispose
your
parent
you're
fine
I
mean
you're,
not
perfectly
fine
by
the
place
that
it
won't
be
any
memory.
E
E
Q
J
Q
E
So
the
the
usual
pattern
that
we
suggest
would
be
that
they
would
have
a
local
variable
rather
than
they
would
get
it
from
activity
current,
but
it
is
true:
nothing
in
the
past
would
have
protected
them
from
sort
of
using
activity
dot
current
as
their
local
variable
and
not
making
their
own.
You
know
legitimate
local
variable,
in
which
case,
if
they
had
written
it,
that
way,
then
having
it
not
be
a
weak
reference
would
be
a
breaking.
J
E
A
E
A
J
J
They'll
call
stop
depending
on
what
sort
of
analyzers
or
other
tools
they
have
it'll
tell
them
hey
you
made
it
or
you
have
a
disposable
thing.
You
should
put
it
in
a
using
statement,
though,
since
you
don't
call
new
depending
on
what
flow
they
do.
They
may
not
understand
what
the
ownership
rules
are,
but
I'd
say
it's
I
think
it's
fine
and
it
matches
the
what
we
approved
for
the
recent
updates
of
if
there's
a
stop
method
that
you're
supposed
to
call
and
I.
Finally,
then
just
be
a
disposable.
B
So
what
I
want
to
point
at
in
the
activity?
The
addition
here
is
the
first
is
a
display
name.
So
when
you
create
the
activity
you
created
with
what
to
call
it
operation,
name
or
whatever,
and
we
got
that
quest
from
open
telemetry
and
to
be
able
to
change
the
name
and
we
thought
about
it-
and
we
found
like
this
would
be
a
pregnant
change.
I
mean
like
coaches,
can,
can
prick
many
people
about
that.
B
So
the
workaround
that
we
decided
to
go
with
is
to
introduce
display
name,
which
is
by
default
to
return
the
operation
name,
which
is
activity
name,
and
this
display
name
can
be
set
about,
I
mean
like
so
so
people
can
can
just
change
the
display
name.
If
you
need
to
so
doing
that
we
just
keep
the
app
compat
and
and
will
give
the
ways
that
you
can
change
the
name
on
the
activity.
I.
D
B
D
E
D
D
E
M
E
D
E
We're
we're
not
aware
of
any
reason
to
have
a
no
property,
the
whole
the
whole
usage
for
the
set
and
get
custom
properties
a
little
bit
vague.
It's
sort
of
open-ended
mechanism
that
people
could
do
extensibility
on
activity,
but
it
really
didn't
seem
well-defined
exactly
what
it
was,
but
they
want
to
put
in
for
this
thing.
D
E
E
So
that's
that's
the
reason
for
having
a
source
there
and
the
reason
it
isn't
available
is
because
we
just
define,
but
there
is
a
global
singleton
source.
It
has
empty
string
as
its
name
and
0.0.0.0
as
its
version
and
that
if
you
call
the
constructor
which
doesn't
provide
a
source,
then
that's
the
single
term
that
we
give
you.
C
C
N
C
N
E
Yes,
I
mean
context
is
just
helping.
You
gather
up
those
properties
more
quickly
and
put
it
into
this
structure.
It's
you
could
do
the
same
thing
without
that
API.
If
you
created
your
activity
context
manually
and
then
call
the
four
properties
on
that
tivity
that
give
you
the
four
fields
of
the
context
and
you
shut
them
all
into
the
constructor
you
you
could
get
the
same
thing
as
what
that
context.
Property
is
doing.
It's
just
attempting
to
make
it
a
little
bit
easier
to
do
that
operation
without
having
to
write
it
yourself.
J
A
I
assumed
this
one,
you
just
catch
the
instance
that
is
given
to
you
right,
yes,
okay,
so
the
gala
was
my
question
with
the
mother.
We
should
take.
I
would
only
dictionary,
but
that
gives
you
if
you'd
stash
the
instance
it's
as
itself,
then
it
makes
sense
to
take
a
dictionary,
because
then
it
remains
in
you
to
go
under
later.
When
you
expose
it.
Oh.
O
E
J
B
Yeah
I
think
I
got
this
from
the
specs
I
mean
as
I
dictionary,
but
no
suspects
I
mean
like
same
limitation
of
dog
netting
for
a
novelty
matauri
but
I
think
I
think
this
should
be
ienumerable.
I
believe
I.
E
A
B
So
what
is
the
design
guidelines
here?
Because
I
hear
to
opposites?
I
mean
opinions.
Yeah,
one
opinion
is
saying
no
I
mean
don't
don't
use
optional
parameters
like
it's
confusing.
We
will
look
at
the
documentation
and
they
think
that
they
have
to
pass
it
or
something
like
this
and
the
other
opinion
saying.
No,
that's
totally
fine
and
the
intellisense
maybe
can
help
use
it.
I.
Don't.
A
Think
Christophe
can
talk
to
the
through
the
findings
at
the
edge
a
usability
study
showed,
but
my
understanding
was
dead.
They
had
some
api's
that
basically
had
like
12
arguments
or
something
on
a
key
scenario
like
you
know,
connect
to
a
server
and
people
missed
in
intelligence.
You
know
the
brackets
that
these
arguments
are
optional,
so
they
tried
hard
to
construct
the
thing
with
12
arguments
and
then
there
wasted
a
lot
of
time.
I
think
for
I
think
the
idea
is
that
for
key
scenarios
that
people
use
a
lot,
you
should
have
simple
API.
A
Is
that
don't
take
that
many
arguments,
even
if
you
default
them,
because
people
miss
that
they're
defaulted?
At
the
same
time,
we
try
to
not
have
visiting
overloads
for
things
that
you
know,
there's
just
an
additional
state
that
you
can't
pass
in
or
not,
but
I
think
in
this
case
it
seems
fine
to
have
an
optional
parameter
like
I.
Would.
R
D
A
D
J
Yeah,
the
guideline
we
wrote
was
I
mean
things
are
very
complicated
and
once
you
introduce
virtuals
and
a
lot
of
overloads
but
effectively
it's
you
can
have
up
to
two
for
free
and
after
that,
you
need
to
make
another
overload.
That
just
removes
all
your
default
and
shows
just
only
the
required
parameters,
but
they're
allowed
sometimes.
A
C
J
F
J
B
A
Usually,
like
we
only
basically
say,
if
there's
some
massive
open
issue
where
we
say:
okay,
this
API
needs
rethinking
this
one
seems
more
like
we
already
gave
a
bunch
of
ideas
and
I
mean
seems
to
me
that,
no
matter
what
they
pick
would
be
better
than
what
they
currently
have
and
you'll
be.
Ok
with
that
I
mean
ok.