►
From YouTube: GitHub Quick Reviews
Description
Powered by Restream https://restream.io/
A
A
B
B
Okay,
so
this
proposal
is
regarding
the
the
metrics
apis
metrics
is,
is
the
way
to
allow
applications,
libraries
and
services
to
to
publish
measurements
for
any
operations
that
it's
performing
or
any
one
example
of
that
I
mean,
like
you
know.
Imagine
like
you
have
like
a
web
service
and
you
can
have
a
counter
reporting
like
a
number
of
requests
that
it's
getting
so
this
is
this.
Is
that
the
ibi
proposal
that
is
implementing
the
open,
telemetry
specification
for
for
metrics?
B
It's
just
to
give
like
background,
as
we
did
in
the
tracing
last
cycle,
I
mean
during
goodness
wine.
So
it's
it's
similar
idea,
so
open
telemetry
is
splitting
the
areas
I
mean
like
tracing
or
matrix
into
into
two
components.
I
mean
one
component
is
called
apis,
and
this
component
apis
is
actually
the
component
used
by
the
libraries
or
the
applications
just
to
use
to
instrument
their
their
code.
B
I
mean
like
their
component
and
the
other
part
of
the
open,
telemetry
architecture
is
they
call
it
sdk,
and
this
will
be
on
the
side
of
the
open,
telemetry
itself
I
mean
so
sdk
is
the
component
that
responsible
for
monitoring
and
aggregating.
Like
the
measurements
and
and
possibly
exporting
it
to
some
back
end,
so
for
this
proposal
we
are
focusing
on
the
apis
that
it
will
be
part
of
the
dot
net
framework,
and
the
other
part
is
that
it
will
be
an
open,
telemetry
side,
which
is,
that
would
be
the
sdk.
B
This
is
not
not
including
this
proposal
so
so
to
to
move
on.
I
mean
like
the
proposed
dbi's
here,
it
will
be,
is
going
to
be
part
of
the
system.
Diagnostics,
diagnostic
source
library
like
like
the
tracing
board,
is
there
also,
so
it
will
be,
it
will
fit
in
the
same
component.
B
Nicely
yeah,
and
also
this
apis
would
be
supported
on
the
on
the
dotnet.net
core
versions
like
three
and
dot
net
five
and
dot
next,
and
it
will
be
also
supported
on
the
full
framework
for
sex
and
mark
before
we
we
go
on
on
the
details
of
the
proposal
I
want
to
emphasize
about.
Like
you
know,
the
naming
we
choose
in
this
proposal
is
is
mainly
picked
up
from
the
open,
telemetry
specification,
and
we
need
to
stick
with
this
name
for
the
sake
to
be
not
to
deviate
from
this
open,
telemetry
standards.
B
B
To
move
on,
I
want
to
to
clarify
about
like
some
terminologies
that
it
used
in
the
open,
telemetry
specification,
so
to
be
clear
about
like
what
we
are
looking
at
here.
So
the
first
terminology
is
called
instrument
and
the
instrument
is:
is
the
class
or
the
type
that
it
will
be
responsible
for
publishing
measurements?
B
Something,
like
you
know,
counters,
something
like
you
know,
histograms
and
so
on.
So
there
are,
I
mean
open,
telemetry
offering
I
mean
two
kinds
of
instruments.
The
first
instrument
is
the
instruments
that
it
get
a
published
measurement.
B
The
second
kind
of
instrument
we
call
it
absorb
observable
instrument,
which
is
it
will
report
only
the
measurement
when
you
ask
for
it.
So
by
default
it
will
not
report
anything
until
you
ask
like
you
know,
for
for
this
instrument
telling,
like
you
know
what
is
the
current
measurement
so
it
and
can
it
report
it
to
you.
B
And
our
apis
is
reflecting
that
the
second
terminology
here
is
the
meter
and
meter
is:
is
a
factory
class
that
it's
it
creates
instruments
meter?
Usually
I
mean
we
expect,
like
you
know,
every
library
will
create
just
like
one
meter
and
from
this
meter
it
can
create
one
or
more
instruments
to
use
to
report
different
measurements.
B
B
Third
terminology:
we
call
it
meter
listener.
This
is
the
class
which
is
we
are
offering
to
allow
listening
to
the
measurement,
and
so
if,
if
any
library
or
any
application
is
publishing
any
measurements,
so
so
the
sdk
I
means
open,
telemetry,
sk
or
any
other
part,
can
listen
to
this
measurement
and
can
aggregate
the
the
measurements
and
can
report
it
or
can
export
it
to
some
back
end.
So
listener
is,
is
a
important
class
to
allow
sdk
to
work.
B
B
So
tags
is
just
like
you
know
a
key
value
pairs
of,
or
we
call
it
tags
and
tags
is
going
to
be
used
with
the
matrix
to,
as,
like
you
know,
adding
like
dimension
to
the
to
the
reported
metrics
for,
for
example,
about,
like
you
know,
imagine
like
you
know,
you
have
like
some
instruments
that
reporting,
like
gc
memory
heap
size
for
example,
and
so
you
can
have
like
you
know
when
you're
working
this
measurement,
you
can
tag
it
like.
You
know
yeah.
B
This
is
gc
memory
and
this
is
generation
zero
or
you
can
report
another
measurement
selling
like
you
know,
this
is
gener
generation,
one
or
generation
two
and
so
on.
So
this
is
how
tags
work,
taxes
also
will
so
a
the
open
trimeter
is
decay
can
aggregate
the
instrument,
I
mean
the
measurements
and
it
can
groove
it
or
filter
it
according
to
the
tags.
B
Nothing
here,
okay,
so
the
first
class,
as
we
as
we
mentioned
meter
meter,
is,
is
the
class
responsible
for
creating
instruments
and
meter
usually
will
have
a
name
and
will
have
a
version.
B
So
name
I
mean
like
you
know,
as
as
I
mentioned
about
like
if
you
have
like
a
library,
so
we
expected
the
name
is
reflecting
this:
the
components
that
that
this
meter
is
created
from
and
version.
This
is
optional
parameter
for
the
version
it
can
be
null.
I
mean
it
can
be
any
other
value
I
mean,
and
as
we
used
in
the
activity
source
in
the
tracing,
the
version
is
just
a
string.
It's
not
really
a
structure
or
an
the.
B
B
Here
so
open
telemetry
is
defining
a
set
of
instruments
that
we
are
going
to
support.
So,
if
you
remember,
I
mean
I,
I
talked
about
two
kind
of
of
instruments:
the
first
instrument
which
is
executed
during
the
request
itself.
We
are
going
to
have
a
two
instruments.
One
is
called
counter
and
one
is
called
the
histogram
and
for
the
other
type
we
will
have
a
three
other
instruments.
B
D
B
B
The
measurements,
so
the
the
factory
method
is
almost
almost
same
ideas
I
mean
so
the
the
only
difference
is
the
first
type
I
mean
first
kind
of
instruments
will
take
just
the
name
description
on
the
unit,
but
the
other
type
of
instruments,
which
is
we
call
it
observable
observable
instruments.
It
takes
also
a
callbacks.
B
A
So
tarek,
yes,
if
someone's
creating
a
counter,
do
you
believe
that
they
are
more
likely
to
have
a
name
and
description
without
a
unit
or
a
name
and
a
unit
without
a
description.
B
For
sure
they
will
have
a
name
for
sure
so,
but
I
I
would
expect,
like
you
know,
I
mean
the
good
practice
is
just
to
to
provide
pulse
description
and
the
honest
in
in
same
time,
but
I'm
not
sure
about.
Like
you
know
some
I
mean
someone
can
decide
to
have
just
description
not
on
it
or
someone
can
decide
to
have
units
without
description.
It's
it's
optional.
A
Okay
and
you
so
you
haven't
seen
or
have
a
strong
feeling
for
somebody
providing
just
the
units
to
say
that
this
is,
you
know,
requests
per
second
or
whatever,
and
not
bothering
a
description.
Okay,
really,
the
question
was:
is
the
parameter
order
right
of
the
optionals?
But
if
we
don't
know
we
don't
no
to
me,
it
feels
like,
if
I
were
doing
it,
I'd
be
like
well,
the
description
is
obvious,
but
you
may
care
what
the
unit
is.
A
Okay,
so
I
would
slightly
think
that
unit
is
more
likely
than
description.
I
guess
so
it
should
be.
First
sorry,
you
know
the
first
optional,
but.
E
So
one
question
I
have
is
like
it's
kind
of:
maybe
you
want
to
talk
about
this
later
when
we
actually
talk
about
the
observable
counter
type,
but
I
just
did
the
sneak
peek
forward
and
what's
a
little
bit
unfortunate
with
the
naming,
is
that
we
have
a
thing
in.net
called
observable,
observable
of
t
or
observable
of
t,
which
basically
is
the
inverse
of
innumerable.
So
instead
of
pulling
you
basically
get
called
with
values,
that's
right.
E
So,
if
observable
counter
would
actually
end
up
implementing,
I
observable,
then
you
wouldn't
need
to
have
this
factory
at
all
right.
The
other
party
could
just
subscribe
to
the
event
and
get
the
values.
B
B
A
So
this
is
a
concern
that
I
brought
up
with
tarek
before
this
meeting,
which
is
yes
right
now,
an
observable
collection
or
observable,
whatever
in
dot
net
means
every
time
it
changes
fire
the
callback-
and
this
is
the
opposite
of
that.
It's
only
tell
the
value
when
I
ask
you
to
and
right
so
I
think
that
we
definitely
want
a
word
other
than
observable,
because
we
don't
want
observable
to
mean
two
contradictory
things.
F
B
Yes
yeah,
so,
as
I
mentioned
in
the
beginning
about
like
you
know,
we
are
preferring
to
stick
with
with
open
telemetry
specification
terminologies
for
the
sake
of
what,
like
you
know,
not
deviating
from
this
is
standard.
We
understand
like
this
is
no.
B
G
H
I
would
agree
with
that
that
that
asynchronous
naming
that
they
call
it
that
in
their
spec,
but
I
think
they're
effectively
proposing
that
everybody
sticks
in
the
api.
This
name
of
observable
counter,
so
it
seems
like
they
only
refer
to
it,
asynchronous
as
a
concept
or
a
principle,
and
it's
not
clear
that
that's
ever
going
to
show
up
in
more
user-facing
documentation,
whereas
this
name
of
observable
counter,
that's,
what's
going
to
show
up
in
user-facing
documentation
and
it's
going
to
show
up
in
other
languages
apis
unless
we
can
get
them
to
change
it.
H
Yet
again,
unfortunately,
there's
been
a
lot
of
back
and
forth
on
the
name
of
that
specific
counter.
That's
probably
the
fourth
name.
Already
that's
been
iterated
on,
so
I
it's
unclear
how
much
more
appetite
anyone
in
that
sizeable
group
has
for
us
to
come
back
and
say:
hey
guys
how
about
this
new
fifth
option
of
a
name
to
consider
for
this
counter,
but
it's
possible.
E
I
mean
everything
is
portable
right,
I
mean
that's
kind
of
you
get
that
for
free
right,
I
mean,
if
you
have
a
list
of
tea,
then
of
course
you
can
ask
at
any
given
point
in
time
how
many
things
are
in
that
collection
right.
So
like
the
like,
I
guess
paul
is
the
default
kind
of
thing
right.
Anything
else
is
kind
of
what
what
you
name
it
right.
You
basically
say
you
can
subscribe
to
a
change
event
right.
E
D
The
the
reason
people
pick
async
versus
sync
is
because
they
have
to
use
some
name
when
they
discuss
something
and
we
have
been
exploring
whether
to
call
that
sync
or
observer
and
calling
this
observable
has
a
lot
of
downsides,
because
when
people
call
something
absorbable,
conquer
and
when
they
talk
about
counter,
others
will
be
confused.
They
will
ask
if
you
mean
the
observable
counter
or
the
non-observable
counter
and
calling
something
non-observable
seems
bad.
D
It's
like
we're
inventing
something
that
cannot
be
observed
at
all,
which
is
incorrect,
so
we
decided
when
people
discuss,
we
always
use
sync
and
async
to
be
explicit
and
in
the
spike
we
also
called
out.
These
are
the
concepts.
But
when
it
comes
to
the
actual
implementation,
we
recommend
people
to
use
observable
counter
as
the
name.
Unless
there's
a
special
reason.
They
don't
want
to
use
observable,
and
there
are
some
cases,
for
example,
in
java,
there's
observer
pattern
and
if
you
see
something
called
observer
full,
it
has
a
totally
different
meaning
here.
D
So
we
also
call
out,
in
the
open
climate,
respect
that
by
mentioning
async
or
also
observable
in
the
spec,
it
has
nothing
to
do
with
the
wikipedia
definition
of
asynchronous
pattern
or
the
observable
pattern.
It's
just.
We
have
to
pick
a
bad
name
here,
because
we
don't
have
a
good
name.
D
So,
regarding
don
x,
I
I
think,
unless
we
have
a
good
reason
to
see
why
observable
is
bad.
For
example,
we
can
say
we
already
have
a
lot
of
observable
footballer
class
in
knowledge
and
having
this,
but
using
a
very
different
approach
would
be
against
the
pattern
and
and-
and
here
goes
the
definition-
then
we're
fine.
But
if
it's
just
very
subjective,
we
think
this
name
is
bad
and
try
to
push
the
open.
Telemetry
part.
E
Well,
but
that
I
mean
that
kind
of
gets
to
the.
I
guess
the
matter
point
of
what
an
api
aspect
means
right.
I
mean,
if
I
mean
I
might
be
an
outlier
here,
but
like
I
generally
don't
believe
that
api
specs
that
prescribe
naming
across
multiple
languages
are
very
viable
for
that
very
reason,
because
the
thing
is
as
a
user
of
this
api,
it's
not
really
useful
for
them.
E
If
the
api
has
the
exact
same
name
in
a
different
language,
what
is
way
more
useful
for
them
is
if
they
use
the
api.net,
that
the
api
feels
like
a.net
api
and
is
kind
of
like
it
fits
into
their
normal
naming
conventions
and
patterns
right
because
nobody,
nobody
just
does
you-
know-
diagnostics,
with
dot
net
right,
they're,
implementing
an
application
in.net
using
asp.net.
They
use
ef.
E
Observable
makes
sense
right
and
yeah
to
me
it's
kind
of
like
it
implies
something
that
is
different.
I
don't
think
it's
a
deal
breaker,
but
I
think
it's
just
it's
just
it
is
surprising
if
you
have
something
like
observable
xxx
of
t
and
you
don't
implement
observable
of
t
it's
kind
of
weird
and
the
pattern
that
you
have
where
you
basically
get
a
funk
is
a
bit
unusual
as
well,
but
it's
not
yeah.
I
don't
think
that's
necessarily
the
worst
thing,
because
really.
A
The
two
are:
are
the
the
simple
name:
one
is
a
stream
of
it
pushes
out
data
as
it
feels
like
it
and
and
things
happen,
and
the
observable
one
is:
is
a
pulling
or
pull
so
like
this
is
really
create
stream
counter
and
create
poll
counter
and
like
those
are,
the
that's.
The
difference
is
one
of
them.
You
have
to
say.
I
would
like
a
new
value
now.
Tell
me
your
current
value
and
the
other
one.
A
Is
it's
just
like
here's,
a
value,
here's
a
value,
here's
a
value,
you
win
a
car
and
then
the
problem
with
the
word
observable
is
in.net.
It
means
that
that
first
thing
really
it's
things
happen
and
hey.
You
win
a
car
because
we
just
changed
from
four
to
five
and-
and
so
this
is
this
word
observable-
is,
I
think,
a
hundred
percent
contradictory
to
the
word
observable
and
dot
net.
D
D
D
If
you
look
at
like
the
the
title,
is
saying
asynchronous
counter
creation,
but
the
actual
name
suggested
in
the
spec,
we're
saying
it
might
may
be
called,
create
observable
counter
and
and
respect.
We
never
try
to
force
people
and
say
you
must
call
that,
because
different
language
can
pick
their
idiomatic
names.
D
So
I
think
we
do
have
some
flexibility,
however,
for
tonight
one
has
to
at
least
consider
like
if
we,
if
we
have
something
called
like
pool
counter
or
something,
then
when
people
use
this,
if
they
come
from
the
open,
telemetry
space,
you
might
say:
oh
I'm
trying
to
get
observable
counter,
but
you
don't
have
to
do
the
mental
translation
versus
people
from
donald.
They
feel
this
is
native.
So
so
we
can't
only
make
one
party
super
happy.
There's
no,
like
always
make
a
way
to
make
both
party
a
hundred
percent
sanctified.
D
E
E
A
great
exercise,
async
right,
but
I
think
in
this
case
yeah
it's
just
weird
because
again,
if
I'm
new
to
the
api
and
I've
never
used
this,
let's
say-
and
I
see
create
observable
counter
my
intuition
is
that
what
I
get
back
is
my
observable:
that's
my
expectation,
yeah,
and
so
basically,
what
you're
describing
here
is
it's
just
it's
not
that
it's
wrong.
It
just
leads
me
down
the
wrong
path,
and
it
just
makes
it
harder
for
me
to
learn
the
api.
If
I
know
that.
D
I
agree:
that's
all
ever
yeah.
However,
I
want
to
call
that
if
we
intended
to
collect
a
pool
counter,
it
might
introduce
other
computers.
For
example,
if
I'm
sending
data
to
prometheus
premises
is
using
scrapper.
That
means
permissive
agent
is
calling
your
application.
Your
application
will
become
an
http
server
that
exposes
an
endpoint
and
when
someone
posts
you
and
say
I
won't
get
metrics,
your
application
will
report
the
data.
D
D
G
D
E
One,
so
let
me
get
this
right
so,
like
the
api
you
have
here,
you
have
create
count
and
you
have
clear
observable
counter
right,
so
I
assume
with
create
counter.
What
you
get
back
is
something
that
the
the
the
caller
of
create
counter
has
to
basically
call
a
method
on
the
counter
of
t
to
push
data
in
versus
with
creative
livable
counter.
I
give
you
the
func,
that
you
know
your
infrastructure
is
calling
into,
and
yeah
basically
has
to
then
do
something
with
that
right.
E
G
E
B
E
B
E
Well,
I'm
not
I'm
yeah,
I'm
not
saying
you
should
all
I'm
saying
I'm
just
observing.
I
know
pun
intended
here
that
there
is
a
discrepancy
and
I'm
just
trying
to
understand
why
that
is
like,
like
I
don't
know
enough
about
the
space.
So
if
you're
telling
me
that
it
just
doesn't
make
any
sense
if
to
have
an
unobservable
cage,
then
I
take
it
like
this.
B
Yeah,
okay
for
observable
instruments
in
general,
about,
like
you,
know,
every
every
factory
method
like
this,
it
has
three
overloads
and
every
every
overload
take
a
different
different
callback.
So
the
first
one
is
like
funk
of
t
just
reporting,
just
the
measurement
value.
Only
it
doesn't
report
anything
else.
The
other
one
is
reporting
a
measurement
value
and
tags
with
it,
and
last
one
is
reporting
a
list
of
of
measurement
values
and
tags.
B
So
every
every
observable
instrument
is
have
this
three
kind
of
overloads.
There
is
two
two
things
I
want
to
to
mention
here
and
that,
like
first
thing,
we
are
proposing
all
of
this
api
in
inside
a
new
name
space.
We
call
it
systemdiagnostics.metrics.
I
want
to
make
sure
that
this
is
every.
Everyone
noted
that
yeah
and
second
thing
yeah
second
thing
is
related
to
the
observable
up
down
counter.
This
counter
is
proposed
currently
by
the
open,
telemetry
specification,
but
there
is
some
discussion
that
they
may
it's
under
discussion.
B
B
Yeah,
this
is
just
like
same
signature
for
different
for
different
instruments.
The
second
second
class
here
is
is
the
instrument-based
class,
and
this
this
class
is
the
best
class
for
all
all
kind
of
the
instruments.
As
I
mentioned,
we
have
two
kinds
of
instruments,
so
this
this
class
for
all
of
the
purpose
of
them
and
this
class,
including
just
the
properties
and
operations
that
it
can
be
performed
in
in
these
two
kinds
of
instruments.
B
So
this
instruments
will
have,
of
course,
I
mean
like
it
will
be
associated
with.
D
B
And
it
will
have
a
name
and
description
and
unit.
You
saw
the
signature
before
I
mean
for
the
name
and
description
and
unit
as
jeremy
mentioned
like
maybe
we
need
to
have
the
units
units
before
description
in
the
signatures,
so
we
can
consider
that
yeah.
Also
this
this
class
have
property
is
called
enabled.
B
This
is
telling
like
if
there
is,
anybody
is
listening
to
this
instrument
or
not.
This
is
just
for
for
optimization.
I
mean
like
if
somebody
want
to
know
like
you
know.
If
anybody
cares
about
this
instrument
or
not
or
somebody
listening
to
it,
so
they
can
detect
that
yeah
last
properties
here
is
called
is
observable,
and
this
is
telling
like
if
this
is
really
observable
instrument
or
it's
the
first
kind
of
answer.
It's
just
returned
true
or
false.
B
Yeah,
so
we
publish
is,
like
you
know,
the
the
way
that
it
will
work.
I
know
it's
like
you
know
you
throw
the
meter,
you
create
the
instrument,
but
while
you
create
the
instrument,
maybe
you
can
you
can
just
like
not
want
to
have
this
instrument
activated
activated
in
the
system
until
you
want
so
you
want.
Just
like
you
know
at
some
point
you
say
like
yeah.
I
have
this
instrument
publish
it,
so
it
will
be
active
in
the
system
and
and
to
allow
like
listeners
to
start
listening
to
it
or
do
something.
B
Yes
yeah,
so
we
have
it
mainly
about
like
you
know,
because,
as
you
see,
we
have
this
protected
constructor,
which
is
which
is
initialized
the
whatever
the
instrument
object,
and
we
expect,
like
you,
know
any
any
one
drive
from
that
will
will
have
to
have.
B
I
need
to
call
this
constructor
and-
and
we
thought
about
like
you
know,
maybe
we
can
just
like
publish,
publish
the
instrument
as
as
soon
as
we
are
executing
this
instrument,
but
we
we
came
about
across
the
scenarios
that,
like
maybe
somebody
is
in
subclassic
instrument
and
want
to
initialize
it
before
publishing
it.
So
if
we
publish
it
automatically
inside
the
constructor,
they
will
not
have
a
chance
to
do
that.
A
H
B
A
A
B
The
next
class
here
is
is
the
best
class
for
the
first
type
of
first
kind
of
instruments
which
is
we
talked
about
like
it
will
be
executed
during
the
request
itself,
which
is
I'm
trying
to
say,
non-observable
instrument.
C
B
Riley
doesn't
like
this
name
yeah.
So,
as
you
see
like
this,
this
class
is
a
generic
and
it
takes
t
and
we
are
going
to
support
some
specific
numeric
types
of
for
this
instrument
and
will
not
allow
different
other
other
different
types.
So,
basically,
you
are
going
to
support
like
bite,
short
and
long
double
decimal
and
float,
so
those
those
are
the
types
that
we
are
going
to
support
with
this.
With
this
kind
of
instrument.
B
B
B
And
we
have
this
overload
so
for
kind
of
optimizations
about,
like
you
know,
you
can
invest
just
one
tag
or
you
can
invest
two
tags
or
you
can
best
three
tags
or
you
can
pass.
I
read
only
spent
of
tags.
This
is
yeah,
so
we
expecting
like
you
know
anybody
will
subclass
this
at
some
point.
We'll
call
record
measurement
to
report
to
this.
This
measurement.
A
F,
sharp
and
vb
can
still
call,
as
as
span
on
the
on
an
array.
A
F
H
F
H
Sure
definitely,
and
so
the
second
thing
was
I
I
mean-
I
think
it
would
be
totally
fine
if
we
wanted
to
add
a
a
params-based
overload
here.
E
I
mean
it
probably
doesn't
need
to
be
in
this
very
spot,
because
this
is
just
for
people
that
are
extending
instruments,
but
I
assume
you
have
pixel
and
apis
where
you
actually,
you
know,
add
stuff
to
the
actual
things
like
counters
and
histograms
right,
but
people
actually
use-
probably
it's
probably
more
important
to
have
that.
I
mean
this
is
basically
infrastructure
right.
E
So
if,
if
they
have
to
go
through
the
spam
thing,
it's
probably
fine,
but
for
the
people
who
are
actually
just
using
this
library,
they
probably
want
to
eventually
pass
in
more
than
three
tags.
We
might
get.
H
F
D
H
H
Yeah
and
it's
possible,
even
the
names
will
be
different.
I
mean
the
it.
That's
certainly
accounted
for
scenario
that
both
the
names
and
the
values
are
changing,
but
I
think.
F
The
the
reason
I
had
asked
is,
if,
if
you
have,
if
the
common
scenario
were
that
some
some
amount
of
data
here
were
the
same
across
multiple
calls,
then
the
ideal
solution
would
be
for
the
caller
to
just
create
some
object
ahead
of
time.
That
represents
all
of
that
data,
and
then
you
could
fill
in
the
holes
as
need
be
and
then
pass
that
one
object
into
the
record
measurement.
F
That
object
could
be
an
array
of
key
value.
Pair
string
object,
if
that,
which
your
fourth
overload
here
would-
or
your
fifth
overload
here-
would
account
for.
Certainly.
H
Yeah
is
it
part
of
the
well,
I
guess
it
depends
if,
if
you're
cashing
that
maybe
you're
still
fine
a
lot
of
this
was
designed
so
that
you
could
call
this
thing
and
not
do
any
allocations.
Obviously
taking
an
array
implies
you've
done
at
least
one,
but
that's
fine,
if
you
cache
it
and
reuse
it
over
and
over
and
over
again
well.
A
H
A
Okay
record
measurement
that
produced
you,
know,
50
tag,
values
or
record
measurement
called
with
50
tag.
Values
is
going
to
create
a
measurement
of
t,
that's
going
to
have
a
way
that
you
can
ask
what
those
tag
values
are
and
that
will
live
longer
than
this
method
did.
So,
where
do
those
tag?
Values
live,
presumably
in
an
array
that
was
created
by
record
measurement.
B
G
H
H
But
if
you
are
in
that
code
or
those
code
paths,
then
your
so
in
the
on
the
dotnet
side,
I
guess
no
allocation
happens
because
we
just
hand
that
data
right
back
out
through
the
listener
interface
to
anyone
who
listens
to
it.
Like.Net
just
acts
as
the
publish
subscribe
mechanism
and
it
doesn't
really
process
the
data.
So.
A
A
A
H
H
H
H
A
I
I
I
G
F
A
B
J
I
I
modern
code
doesn't
necessarily
care
about
cls
compliance
anymore.
Even
the
ca,
sharp
compiler
does
not
correctly
tell
you
when
you're
not
cls
compliant
today,
like
read
only
span
itself
is
not
cls
compliant,
so
it
would
be
great
if
we
just
supported
at
the
very
least
the
10
core,
primitive
types
and
short
of
that.
Also
look
at
expanding
this
to
say.
Take
I
number
of
t
in
the
future
when
we
actually
have
the
generic
math
supporting.net,
you
know
seven
or
post
seven
since
we're
shipping
the
preview
of
that
and.net,
six
anyways.
J
F
B
J
Yeah
and
we're
likely
going
to
be
adding
in
128
here
in
the
future
c
sharp's
likely
adding
checked
and
unchecked
operators,
in
which
case
we'll
be
able
to
add
that
in
which
case
in
128,
would
be
cls,
compliant
and
a
primitive
type,
because
it's
an
abi
type
right.
But.
A
B
D
H
At
the
very
least,
I
suspect
we
should
just
wait
to
finish
this
discussion
until
we've
looked
at
the
listener
api,
because
every
type
that
we
support
here
imposes
a
burden
on
people
that
implement
listeners,
and
once
you
sort
of
see
that
trade-off,
then
you
might
have
a
different
opinion
about.
What's
the
right
trade-off
to
make.
B
Okay,
yeah,
we
go
because
yeah
next
one
is
observable
instrument
of
t,
and
this
would
be
the
best
class
for
the
observable
instrument
kinds,
which
is
we
talked
about,
and
this
one
of
course
I
mean
like
you
know
it
will
have
this
constructor,
which
is
it
will
take
the
meter
name
and
description
like
any
other
instrument
and
also
it
will
have
the
observed
method.
This
is
the
most
important
method
that
this
is
the
method,
that
user
or
the
consumer
of
the
instruments
is
going
to
call
to
get
the
measurements.
B
B
No,
I
mean
it
doesn't
need
to
inherit.
From
that
I
mean
like,
as
I
mentioned
in
the
beginning,
we
have
two
different
kinds
of
of
instruments,
so
any
simultaneously
really
is
really
the
first
kind
of
instrument,
and
observable
instrument
of
t
is
the
second
one.
So
we
are
trying
to
to
distinguish
between
these
two.
B
Kinds
yeah
internally
internally
I
want
like
you
know
we
will
have
a
way
I
mean,
like
you
know,
from
one
calling
observe
and
reporting
stuff
I
mean
so
the
same.
The
reported
measurement
will
be
reported
to
the
listener,
the
same
way
that
the
other
instrument
is
reported,
and
so
we
will
have
an
informal
way
in
the
listener
to
to
get
the
measurement
either
from
instrument
or
from
instrument
of
yeah.
A
Observer
and
eric,
I
think
the
answer
to
your
question
is
we
have
three
concepts
and
only
two
words:
there's
right
observable
instrument,
the
thing
that
is
the
opposite
of
the
observable
instrument
and
then
the
thing
that
is
either
of
those
kinds
of
instrument,
and
we
have
observable
instrument,
comma
instrument,
comma
instrument,.
I
A
Right
because
the
instrument
of
t
is
because
it
added
the
data,
will
now
like
you're
putting
data
into
the
system
and
it
needs
to
flow
down.
This
is
the
stream
instrument,
and
this
is
the
polled
instrument,
but
because
there's
not
a
word
for
the
stream
here,
it's
the
absence
of
a
word
instrument.
Instead
of
just
an
instrument,
that's
right.
I
A
A
H
I
I
A
Would
I
would
be
happy
with
something
like
you
know,
streaming
instrument
which
indicates
data
gets
pushed
in
at
one
end
and
flows
out
the
other
without
anyone
else
asking
for
it,
but.
I
A
I
mean
so
I
100
agree
with
you.
I
just
you
know
the
best
word
I've
come
up
with
is
streaming
and
telemetry
shot
it
back
so,
but
I
I'm
taking
a
note
that
says
yeah.
Ideally,
we
would
put
a
prefix
on
this
type
to
help
better
distinguish
it
from
the
other
kind.
B
Yeah
one
thing
to
note
here
observe
is
returning
like
a
list
of
measurement
and
measurement
would
be
the
next
class.
We
are
looking.
D
B
We
will
look
at
and
measurement
basically
I
mean
it
has
like
the
value
and
it
has
the
tags.
So
this
is
only
two
things
that
measurement
will
have
as
I
mentioned,
but,
like
you
know,
this
measurement
will
be
reported
from
the
observe
in
the
observable
enzymes.
A
Any
I
think
you
want
a
fourth
constructor,
which
is
just
t
value.
Otherwise,
it's
going
to
create
an
empty
array.
B
F
Yeah
for
params
it
allocates
a
zero
like
correct.
B
B
F
Up
so
4
6
definitely
has
a
ring
update,
but
we
we
don't
want
callers,
to
have
to
break
that,
though,
like
that's
just
a
bad
experience.
H
A
Yeah
I
mean
it
looks
like
array:
empty
was
added
in
that
standard,
one
three.
So,
but
again,
I
don't
think
anybody
ever
taught
the
compiler
that
that
was
a
better
thing
to
do
than
you
know.
New
t,
bracket
bracket
or
new
t
bracket
zero
on
a
params
call.
F
F
B
Yeah,
but
I
want
to
say
about,
like
you
know,
this
one
is
called
from
the
observable
instrument.
B
I
mean
observed
method
which
has
returned
this
list
of
instruments
list
of
measurements,
and
this
is
not
a
perf
hot
path
I
mean
because,
like
we
expect
like,
we
will
call
and
observe
every
while
I
mean
it's
not
regular
reporting,
so
so
a
location
here
is
it
would
be
reasonable.
I
need
to
have
this
first
and
second
about,
like
you
know
whatever
gets
reported
here,
is
it
will
get
consumed
directly
by
the
listener,
so
the
listener
can
just
like
go
enumerate
those
and
do
whatever
it
wants.
H
F
Oh
maybe,
but
it's
if,
if
you
don't
think
this
is
going
to
be
a
proof,
sensitive
code
path,
then
leave
it,
as
is,
I
guess,.
H
H
E
B
Next,
it
will
be
the
implementation
of
concrete
classes
of
the
instruments
and
yeah
for
eric
earhart.
I
mean
this
is
where
I
mean
this
is
a
face
using,
I
mean
types
that
it's
going
to
be
used
by
the
users,
as
you
see
about,
like
counter
of
t,
is
inheriting
from
an
instrument
of
tv,
yeah
and
basically
those
I
mean
every
every
instrument
of
those
will
have
this
different
kind
of
operation,
which
is
like
counter.
It
will
have
ad
the
nexus
will
be
histogram.
We
have
record,
and
internally
I
got
like
you
know.
B
The
implementation
of
this
classes
is
going
to
be
like
when
you
call
add
on
counter
internally.
It
will
cause
record
measurement
from
the
instrument
of
t,
which
is
will
get
reported
to
the
whatever
listener
at
the
end,
and
you
notice
also,
we
have
this
overview
that
it
takes
around.
You
know
yeah
plus
overlooks.
B
This
is
what
was
suggested
initially
like
to
have
a
brown
around
the
overload
that
will
the
fixed
problems
yeah.
A
So
yeah,
so
if
I
have
a
counter
so
I'm
I
have
a
counter
that
is
the
total
number
of
web
requests
that
I
have
received.
When
I
call
this,
do
I
give
you
the
new
total?
Do
I
give
you
the
number
that
has
okay
exactly.
A
D
A
H
D
Yes,
so
so
we're
saying,
like
the
the
asynchronous
instrument,
is
always
going
to
take
the
absolute
value,
but
we
have
never
tried
to
put
a
concrete
example,
but
I
think,
what's
being
suggested
here
makes
sense
like
in
the
parameter
name.
We
can
explicitly
give
people
that
information
that
they
must
pass
in
the
delta
value.
A
D
D
I
I
agree
with
kind
of
because,
like
the
word,
increment
and
decrement
seems
to
be
used
in
in
some
scenario
where
it
means
like
atomic
operation
for
the
cpu,
and
it's
only
like
add
one
or
minus
one.
D
A
Like
my
my
thinking
of
this,
and
maybe
I'm
the
outlier
is,
I
see
the
telemetry
stuff
as
a
stream
and
add
to
me
means
I'm
adding
a
payload
or
I'm
adding
a
data
point
in
the
stream,
so
I'm
thinking
of
it
as
a
list
not
as
as
a
number,
so
I
see
add
as
gain
an
additional
value
and
not
you
knew
what
your
previous
answer
was.
Please
add
this
to
it,
but
you
think
this.
A
Well
again
like
it
can,
it
can
make
sense,
but
I'm
thinking,
if
I'm
doing
like
web
requests
and
I'm
just
thinking,
I'm
pushing
this
into
a
telemetry
stream
that
it
doesn't
occur
to
me
that
I
would
zero
out
my
own
counter.
So
I
would
I
mean
yes
if
I
knew
that
I
would
call
add
one,
but
if
I'm
only
calling
add
on
a
timer,
then
it
it's
like.
Oh,
I
need
to
to
add
and
then
set
my
counter
back
to
zero.
Otherwise
I'll
get
like
oh
a
hundred
and
then
like
I
got
another
hundred.
A
H
A
Think
delta
is
fine,
because
it's
how
much
you
want
to
change
it
from
the
last
time,
of
course,
you're
going
to
throw
if
it's
a
negative
number
according
or
rather
you
say
that
you
only
support
non-negative
increment,
but
but
yeah
I
mean
it's
still:
yeah
delta.
J
Are
we
concerned
about
the
case
for
float
and
less
so,
but
for
double,
but
it
still
exists
of
once
it
hits
2
to
the
power
of
52
or
2
to
the
power
of
24.
plus
one
is
no
longer
going
to
have
any
effect.
J
Well,
the
difference
here,
the
the
difference
here
is
that
for
integers
you
have
a
clearly
defined
limit
of
you
know,
2.14
billion
and
plus
one
or
plus
anything
is
always
a
deterministic
operation,
always
mutates
the
original
value.
However,
with
float,
there
is
a
sliding
scale
of
what
the
epsilon
is
between
values,
and
so,
even
though
the
maximum
range
of
float
is,
you
know
one
e45,
once
you
hit
2
to
the
power
of
24,
which
is
16
million,
the
delta
between
values
becomes
two,
so
adding
one
no
longer
has
any
effect.
J
It
returns
the
original
value,
the
input
value,
and
so
you
so
users
frequently
hit
issues
with
float
and
double
where
they
expect
something
to
have
an
effect
when
in
practice
it
doesn't
because
of
how
it's
represented
this
counter.
Actually.
H
But
it
is
still
fair
to
say
it
is
very
likely
that
the
thing
that
is
listening
itself
will
internally
have
a
float
or
a
double
or
something
like
that
and
then
yeah
once
you
reach
that
limit
at
which
the
episode
is
bigger
than
one.
You
probably
will
have
that
resolution
challenge
where
it
will
stop.
I
mean,
what's.
A
A
Or
double
like
your
the
fact
that
you
said
that
you
want
to
measure
something
in
a
non-integer
way
means
you're
facing
loss
of
precision
at
any
moment.
So.
I
H
I
would
expect
the
common
case
would
either
be
you'd,
have
a
counter
of
int
a
counter
of
long
or
you
might
have
a
counter
of
double
just
because
you
wanted
really
giant
numbers
that
double
is
going
to
represent,
but
the
only
way
you're
going
to
get
to
those
giant
numbers
and
any
you
know,
app
that
doesn't
run
for
years-
is,
if
you're,
adding
more
than
one
at
a
time
yeah.
That
would
be
my
hunch.
A
You're
trying
to
add
how
many,
how
much
money
you've
made
since
the
last
call
and
you're,
foolishly
not
using
decimal
or
or
integer.
G
A
B
B
A
So,
while
add
is
meaning
that
someone
somewhere,
if
they're,
actually
storing
a
rolling
total
for
you
like
they
will
do,
arithmetic
plus,
but
for
as
far
as
the
api
is
concerned,
ad
is
actually
also
kind
of
just
like
here's,
a
new
data
point
that
represents
the
change
since
last
time.
H
It's
you
could
interp,
you
could
interpret
add
to
specifically
mean
you
know,
put
a
new
data
point,
although
that
was
not
the
reason
that
the
word
ad
was
selected.
A
Right,
but
that
was
the
the
ambiguity
that
I
right
suggested
I
have,
but
because
on
all
of
this,
it's
eventually
it's
getting
hooked
up
either
to
you
know
some
alarm
bot
or
it's
being
hooked
up
to
a
graph,
and
what
the
ad
means
here
actually
is
put
a
new
point
on
a
graph
and
and
and
what
you're
giving
is
how
much
since
the
last
point,
because
it's
a
yeah
all
right
anyway,.
H
I'd
rename
measurement
delta
to
try
and
help
alleviate
that
ambiguity.
Yep.
I
I
B
F
B
F
Yes,
a
question
on
on
this-
I
I
don't
think
this
was
answered
earlier,
so
if,
if
we
have
a
poll
model
for
observers
to
say,
please
give
me
the
latest
value.
Please
give
me
the
latest
value
right.
What
does
it
mean
with
response
to
a
counter
that
just
keeps
getting
stuff
added
to
it
like?
What
is
the
latest
value
in?
That
scenario?
H
I
was
just
going
to
say
I
mean,
because
counter
doesn't
derive
from
observable
instrument.
There
is
no
api
there.
That
says,
give
me
the
latest
value.
It's
just
here
is
a
stream
of
values.
Listener
do
with
this.
What
you
will
now.
It
is
also
true
that
the
listener
will
overwhelmingly
likely
say
what
I
want
to
do
with
all
the
values
I
get
from.
H
My
counter
is
add
them
up
and
store
a
rolling
total,
but
that
is
sort
of
their
their
choice
as
to
how
they
want
to
interpret
this
stream
of
numbers,
and
there
is
in
open,
telemetry,
there's
likely
to
be
configuration
that
says
you
don't
have
to
treat
this
numbers
in
the
default
way.
If
you
don't
want
to,
you
can
treat
them
in
some
other
way
and
define
by
configuration.
B
Yeah
next
we
have
histogram,
I
mean
this
is
also
it's
drive,
driving
from
instrument
of
t
yeah,
as
as
mentioned
here,
instagram
can
be
used
to
report
arbitrary
values
that
are
likely
to
be
statistically
meaningful.
B
D
A
Mean
in
this
case,
it
makes
sense
to
me
you're,
for
because
this
one
is
raw
samples
right.
So
it's
yep
it
is
you
measured
a
thing,
and
you
suggest
that
the
representation
of
that
is
a
histogram.
So
each
thing
is
a
thing
you
measured
as
opposed
to
the
counter
where
it
could
have
been
things
you've
measured
over
the
last
five
minutes,
and
so
it
the
counter
could
already
be
an
aggregation,
which
is
why
clarifying
what
it
means.
D
D
B
B
And
we
have
observable
up
up
down
counter,
as
I
mentioned
this
time
still
under
discussion
in
the
open,
telemetry
specs.
So
we
are
not
going
to
expose
this
one
till.
We
are
sure
that
it
will
be
included
in
the
open,
telemetry
yeah
and
last
last
one
is
called
observable
gauge,
which
is
which
is
like
instruments
that
can
report
like
you
know
the
current
room
temperature
or
something
like
this,
and
of
course
I
mean
all
of
them,
is
just
like.
Have
this
overload
override
for
observe.
H
And
technically
that
that
observe
method
is
not
part
of
their.
I
mean
that's
not
publicly
visible
api,
because
the
types
are
sealed
right
like
there's
no
way
you
could
derive
from
that
further.
So
really,
there's
no
way
that
anyone
could
ever
know
that
that
method
is
is
hiding
there
under
the
covers.
H
G
A
H
A
H
H
J
B
My
library
I
mean
I
can
my
library
can
create
observable
counter,
for
example,
and
and
then
this
line
I
mean
this
observable
counter
object,
will
wait
just
to
get
called
back
through
observe
and
when
it
gets
called
back,
I
mean
so.
My
code
will
going
to
report
the
measurement
at
that
time
yeah.
This
is
outward.
A
H
F
Earlier
you
had
demonstrated
that
there
was
an
enabled
property
on
the
instrument
based
class.
I
think
that's
where
it
was.
How
do
you
know
if
someone's
actively
observing
this
yeah.
B
Okay,
I
think
this
is
the
last
time
we
need
to
discuss.
This
is
the
meter
listener,
which
is
it
can
listen
to
to
this
all
types
of
instruments.
We
have
either
the
observable
one
or
the
none
of
the
rules.
B
B
Let's
read
only
span
of
tags
and
they
will
take
some
things
called
state,
and
this
state
object
is
this
kind
of
opaque
object
that
when
somebody
starts
listening
to
any
instrument,
they
can
pass.
This
state
object
to
us
and
when
we
report
the
measurement
later,
we
can
pass
back
this
state
to
them,
so
they
it
will
help
them
for
in
the
like
aggregation
or
avoid,
like
some
lookup
later,
when
the
measurement
gets
reported.
A
So
you
have
a
type
called
measurement,
that
is
a
t
value
and
a
read-only
span
of
key
value
pair
of
string
object
tags.
Why
don't
you
just
pass
measurement
here.
F
A
Yeah
I
do
because
I
pulled
a
up
measurement.
I
am
going
to
jump
backwards
slightly.
This
truck
should
be
declared
read
only
right.
I
B
Yeah
yeah,
it
should
be
the
same
yeah
yeah,
that's
a
good
catch
too
yeah.
Thank
you.
F
A
J
J
F
So,
to
be
fair,
one
of
the
reasons
that
we
that
we
fight
away
from
unmanaged
constraints
in
the
past
is
we
had
a
lot
of
situations
where
callers
themselves
were
writing
generic
code,
where
callers
didn't
really
know
what
the
t
was
ahead
of
time.
In
this
case,
you
actually
do
know
what
the
t
is
like
if
you're
writing
code.
For
this,
you.
B
F
At
the
call
site,
if
t
is
it
on
double
flip,
whatever,
because
you're
using
that
concrete
type,
so
I
don't
think
it's
going
to
bite
colors
of
this
api
as
much
as
it
did
bite
us
in
the
past.
J
Can
we
use
it
from
vb
and
f-sharp
f-sharp
supports
unmanaged
today
I
don't
know
what
vb
does
it
is
not
support
unmanaged,
okay,
yeah
then
then
it
needs
to
be
struck.
I'd
assume
I.
A
Need
to
ask
a
clarifying
question:
fred
vb
will
fail
because
it
doesn't
support
the
unmanaged
thing
or
vb
doesn't
support
mod
rex
at
all
and
therefore
ignores
them
and
therefore
will
support
it.
A
I
A
A
closed
generic
right
like
the
t
is
the
constraint
is
whatever
we
think
is
the
most
helpful
to
the
system,
because
it
there
is,
no
you
get
to
make
your
own
struct
and
pass
it
in
or
you
can
make
a
type
that
counts
as
unmanaged
and
get
to
pass
it
in
like
it's.
It
is
simply
it
supports
the
five
things
that
supports,
and
you
know
ten
if
tanner
gets
his
way.
A
You
could
create
a
measurement
callback
of
my
custom
type
and
the
delegate
system
won't
care,
but
the
when
you
said
create
when
you
called
create
counter
of
my
custom
type.
It
said,
I'm
sorry.
I
only
support
these
five
types.
I
B
Okay,
yeah
for
meter
listener.
We
have
the
normal
constructor,
doesn't
take
anything
you
just
just
create
it.
The
first
one
is
instrumented
publish.
This
is
the
first
property
which
is
of
type
of
action
now,
which
is
take
instrument
and
the
listener
itself.
B
This
this
property
is
going
to
be
called
on
the
listener,
every
time
that
the
an
investment
is
get
produced.
I
I
mean
it's
get
enabled
in
the
system,
so
so
at
that
time
I
mean
whoever
the
listener
I
mean
gets
this
notification
about.
Yeah
there
is
here
here
is
a
new
instrument
and,
and
the
listener
can
decide
about-
like
you
know,
if
you,
if
you
need
to
do
something
with
that
to
to
start
listening
to
the
measurement
of
this
instrument,
or
just
like
you
know,
ignore
it.
B
So
this
is
this:
is
a
instrument
published
the
other
one
is
measurement
completed.
This
is
the
this
is
the
reverse
of
insulin
published,
so
innocent
published
is
just
like
you
know,
get
called
when
a
new
innocent
get
published
to
the
system
and
measurement
completed
is
when
the
measurement
as
an
instrument
is
going
to
be
like
unpublished,.
H
So
I
wouldn't
quite
frame
it
that
if
you,
if
so
below,
there's
an
enable
measurement
events.
So
if
you
want
to
listen
to
the
stream
of
measurements
coming
from
an
instrument,
you
call
that
and
then
and
then
we
start
streaming
it
to
you
and
then
and
then,
and
only
then,
when
the
instrument
goes
away.
We
tell
you
that
the
measurements
are
complete.
If
you
never
sign
up
to
listen
to
the
measurement,
then
we
don't
tell
you
that
it's
complete
later,
when
it's.
A
B
Yeah,
the
second
okay
to
answer
the
first
one
about,
like
you,
know,
yeah
I
mean
like
we
can
have
this
in
the
constructor,
but
I
mean
like
I'm,
not
seeing
any
problem
to
have
this
in
the
constructor
I
mean
so
so
we
can.
We
can
have
a
constructive
text,
some
parameters,
that
it
takes
like
this
action
and
and
they
have
it.
The
second
thing
is
like
instrument
published,
is
taking
the
second
one
meter
listener,
as
as
a
prompter.
B
A
A
Part
of
my
question
of
why
isn't
that
a
constructor
parameter
is,
do
you
need
the
minus
equals
and
do
you
need
to
be
able
to
replace
it
and
like
if,
if
it's
just
supposed
to
be
a
delegate-
and
it's
you've
created
it
and
it's
never
going
to
change,
then
that's
the
constructor
property,
but
but
yes,
it
does
actually
feel
more
like
it's
static
events
instead
of
instance,
events
off
of
some
listener,
like
it
feels
it
feels
weird
that
it's
an
instance
thing
that
you
don't
know
who
you
are.
H
So,
let's
see
I
I
there's
probably
not,
as
I
don't
know,
if
there's
any
particular
reason
not
to
have
it
be
an
event
pattern
versus
the
the
action
delegate,
I
think
the
common
use
case
would
be.
People
would
set
the
delegate
once
when
they
created
the
thing
and
then
not
change
it
further,
but
that's
possible.
They
could
change
it
further
if
they
wanted
to.
A
I
guess
I'm
just
having
this
weird,
like
you
have
400
instruments
and
20
different
listeners.
Does
everybody
who's
ever
created
a
listener,
see
all
of
the
the
multiplicative
thing
wash
through
all
of
their
things?
So
you
get
in
your
callback
that
somebody
else
has
a
listener,
and
you
can
now
call
enable
on
that
listener,
like
that,
you
need
to
check
if
it's
the
listener
that
you
care
about
like
that's,
why
this
seems
weird
like
because
you're
creating
the
listener
and
then
in
the
callback
you
get
the
listener,
but
is.
H
Yes,
that
that
listener
is
always
this.
Okay,
like
we're,
basically
just
handing
you
this
we're
handing
you
a
reference
to
your
own
listener,
so
in
particular
imagine
that
you're
passing
this
inside
that
constructor,
like
imagine,
we
made
that
a
constructor
parameter
and
you
want
you
want
in
response
to
some
instruments.
You
want
to
say:
oh
I'd,
love,
to
call
enable
measurement
events
on
that
instrument,
because
I
want
to
begin
listening
to
it
like.
A
H
A
A
Some
other
event
and
then
calls
the
call
back
with
that
instrument.
Comma
me:
yes,
so
it's
just
a
it's
a
confusing
looking
convenience
wrapper
exactly
okay,.
H
H
C
H
So
like
in
this
in
this
particular
pattern,
you
could
imagine
replacing
meter
listener
with
just
listener
and
you
would
have
closed
over
your
your
field
there.
If
we
moved
it
into
being
a
constructor,
then
you
would
not
be
able
to
close
over
the
object
because
you
wouldn't
have
finished
creating
it
yet.
A
Emo
point
of
order
we
have
15
minutes
left.
Should
we
suspend
this
and
jump
to
fred's
thing.
E
C
A
We
we're
stopping
before
metric
listener,
we're
going
to
do
the
other
thing
and
then,
if
that
wraps
up
quickly,
we
can
come
back
to
this.
Otherwise
it
comes
back
on
tuesday
at
meter
listener
yeah.
E
F
B
B
They
are
waiting
for
this
because
they
want
to
start
implementing
the
sdk
part
in
the
open
telemetry,
which
is
depend
on
this
apis,
and
we
need
to
get
this
as
early
as
we
can
to
expose
it
for
them.
So
they
can
start
implementing
the
sdk
and
we
need
to
have
the
whole
work
will
be
part
of
the
preview
file.
B
Yeah
I
mean
like
I
can't
yeah.
Of
course
I
mean
I'm
doing
some
progress
in
the
implementation
itself,
but
I
won't
make
sure
that,
like,
like
I
mean
like
if
we
delay
the
rest
of
the
review
on
tuesday,
maybe
I'm
not
sure
about,
like
you
know
if
I
can
get
like
some
major
comments,
that
need
like
a
big
re-architecture
of
the
whole
thing
or
or
it
depends
on
your
life.
This
is
why
I
don't
want
to
get
surprised.
I
need
to
wait
till.
F
Tuesday
night
no
and
I
I'm
sympathetic
to
that,
it
sounds
like
it
sounds
like
a
big
re-architecture
is
not
being
requested,
and
at
that
point
it
should
be
feasible
to
optimistically
start
implementing
the
api
that
you
had
proposed
and
then
make
whatever
targeted
changes
are
necessary
before
checking
so
things
can
run
in
parallel.
A
Okay,
that's
entirely
up
we're
we're
bowing
to
the
will
of
our
robot
masters.
Thanks,
everybody,
okay,
interpolated
string
support
part
three:
five,
one
niner
six,
two.
C
Red
all
right
so
yeah,
so
this
is
basically
we.
We
previously
looked
at
interpolated
string
support
in
over
two
sessions
and
we
came
up
with
names
and
we
came
up
with
with
general
general
shapes
of
these
trucks
and
we're
not
proposing
really
changing
anything
major
here.
C
The
big
difference
is
ldm
met
and
we
went
through
some
of
the
open
questions
and
we
decided
to
try
and
simplify
the
user
experience
a
bit
by
requiring
that
interpolated
string
build
the
types
that
are
valid.
Interpolated
string
builders
need
to
be
marked
with
an
attribute,
and
then
the
compiler
can
know
that
this
thing
is
actually
intended
to
be
an
interpolated
string
builder
and
you
don't
get
some
of
the
because
some
you
all
were
concerned
as
well
about
like.
Oh
what,
if
the?
What?
C
If
a
method
is
missing
and
suddenly
overload
resolution
changes
so
that
by
just
having
the
attribute,
we
simplify
that
and
make
it
so
that
doesn't
actually
like
have
have
a
missing
have
all
sorts
of
unintended
spooky
action
at
a
distance,
and
so
the
proposal
here
is
number
one
that
we
add
under
system,
runtime,
compiler
services,
an
interpolated
stringbuilder
attribute.
C
This
is
just
a
simple
attribute
that
can
be
put
on
classes
and
structs
doesn't
allow
you
can't
put
multiple
they're
not
inherited,
and
the
idea
behind
putting
it
in
system
runtime
compiler
services
is
that,
yes,
this
is
intended
to
be
user
used,
but
only
by
a
very
few
users
and
to
me
it
felt
more
in
line
with
something
like
a
module
initializer
attribute,
which
is
also
in
system
runtime,
compiler
services.
And
so
that's
that's.
Why
that's
there
and
then,
because
we
now
have
an
interpolated
stringbuilder
attribute,
which
then
gets
shortened
everywhere.
C
C
That
is
the
thing
that
the
compiler
knows
about
specially
and
then,
if
you
scroll
down
a
bit,
you
can
see
the
other
proposed
name
changes
which
are
interpolated
string
span
builder,
as
opposed
to
right
now,
where
it's
just
interpolated
span
builder
and
then
interpolate
a
string,
append
format
builder,
where
right
now
again,
it's
interpolated
append
format
builder.
A
Okay,
so
there's
not
a
language
there's
only
a
human
problem
with
interpolated
string,
builder
and
square
brace,
interpolated
string
builder
right,
like
the
compiler,
will
see
that
interpolated
string
builder
is
not
an
attribute,
so
it
couldn't
be
an
attribute.
So
it'll
keep
searching
for
interpolated
string
builder
attribute.
C
I
haven't
actually
verified
that
that's
true,
but
even
if
it
even
if
it
was
true,
I
still
think
the
human
problem
is
is
important
enough
that
we
should
fix
it.
A
Fair
enough
so
yeah
I
will
say
so.
I
was
trying
to
talk
to
some
other
people
who
you
know
haven't
been
in
the
previous
meetings.
Aren't
part
of
fxdc
aren't
part
of
ldm,
aren't
part
of
roslyn
to
get
some
opinions
on
some
of
the
naming
of
things
here
and
I'll
say
the
the
most
concrete
piece
of
feedback
that
I
got
is.
This
is
all
weird
because
the
builder
and
the
thing
are
the
same
thing
like
we're
not
actually
building
things
for
the
most
part.
A
It's
the
the
api
that
we're
calling
the
builder
is
really
the
doer
and
that
if
we,
if
we
added
a
thing
so
right
now,
the
default
one
has
two
string
and
clear.
If
we
renamed
tostring
and
clear
to
build,
then
we
would
actually
have
a
clear
you
have
a
return
value,
which
is
the
builder
and
you
have
or
you
have
the
return
value,
which
is
the
built
thing,
and
you
have
the
builder,
which
is
the
thing
that
you
paint
that
the
compiler
knows
how
to
find.
A
We
can
figure
out
a
way
to
link
them,
and
then
we
now
have
this
easy.
We
name
the
builder.
The
builder
and
we
name
the
other
thing,
whatever
the
other
thing's
supposed
to
be,
because
it's
the
produced
thing
and
then
we
can
come
up
with
a
formula
and
for
the
refstruct
things
we
would
make
that
I
figured
in
my
head
is,
we
would
make
it
be
void,
build
which
means
past
the
thing
itself.
I
am
aware:
that's
a
big
change
and
we
don't
have
time
to
talk
about
it.
A
A
C
A
The
other
thing
that
I
came
up
with
is
you
know:
no
one
ever
sees
this.
No
one
ever
sees
the
default
builder,
so
it
doesn't
matter
what
we
name
it.
We
could
name
it
qwerty
and
no
one
would
care,
but
when
it
comes
to
the
other
things
so
interpolated
string
span
builder
my
parser
lexer,
whichever
one
is
the
right
thing
of
extracting
semantics
from
the
tokens,
see
string
span
and
we're
building
string
spans,
but
we're
not
building
string
spans.
A
We're
building
like
we're
working
with
spans
the
string
is
thrown
in
because
we're
calling
it
the
interpolated
string.
So
I
actually
think,
instead
of
doing
interpolated
string
foo
builder,
we
want
foo
interpolated
string
handler
because
all
it
does
is
handle
it.
It
doesn't
necessarily
build
a
string.
It
doesn't
necessarily
build
anything.
A
C
So
while
I
don't
have
a
huge
like
I
don't,
I
don't
feel
super
strongly
about
span.
Interpolated
string
builder
versus
interpolated
string
span
builder.
The
thing
the
thing
that
I
do
want
to
make
sure
is
that
you
know
so:
on
the
one
hand,
yes
you're
you're,
it's
actually
neither
parsing
or
relaxing
that
extracts
semantic
information.
Damn
it
from
strings.
C
C
Your
bind
your
binding
step,
okay
is
associating
string
and
spam,
but
that's
not
that's
not
the
thing
that
is
associated
right,
interpolated
strings
is
the
thing
that
is
associated,
so
perhaps
a
reordering
here
to
put
interpolate
a
string
builder.
So
you
have
a
a
a
single
thing
that
you
latch
on
to
that
says.
This
is
a
builder
that
hand
a
builder
type
that
handles
interpolated
strings
and
it
handles
it
in
relation
to
spans.
A
So
in
this
case
it
would
be
span
interpolated
string
builder
and
then
maybe
we
want
to
come
up
with
a
better
name
then,
given
that
it
is
not
all
spans,
but
for
the
things
like
append
here
right,
it's
a
append
format,
interpolated
string
builder,
and
I
think
that
that
actually
looks
perfectly
reasonable.
A
C
The
interpolated
string
is
being
built.
Okay,
that's
that
that
is
what
is
happening.
The
interpolator
string
is,
is
syntactically.
Being
transformed
into
a
series
of
builder
calls
right,
but
an
interpolated
string
is
not
what
comes
out
it
is,
it
might
not
be
a
string,
it
might
not
be.
The
final
form
might
not
be
a
strain.
A
The
interpolated
string
is
being
handled,
which
is
why
I
suggest
handler
instead
of
builder,
because
the
the
input
is
an
interpolated
string,
but
the
output
could
be
a
formatted
log
message.
It
could
be
a
total,
no
op.
It
right
like
it's,
not
necessarily
building
anything,
but
it
is
handling.
E
C
E
The
reason
I
suggest
this
is
to
actually
have
a
simpler
term,
because
otherwise
you
just
keep
combining
you
know
these
things,
and
then
we
end
up
with
these
java
names
with
manager,
factory
provider
somewhere
in
the
middle,
and
then
it
becomes
this
mind-bending
exercise
of
what
it
actually
like.
What
is
actually
the
thing
that
does
the
thing.
C
A
Yeah,
I
guess
I
mean,
like
I
see
interpolator
and
interpolated,
as
obviously
linked
words.
C
C
A
Right
well,
because
you
know
it's,
the
dollar
sign
syntax
means
you
have
a
string
that
will
be
interpolated
and
then
it
is
interpolated
by
an
interpolator
or
unless
it's
an
interpolater
e-r-o-r
is
the
thing
that
I
would
defer
to
my
copy
editor
on.
K
Interpolate
there
we
go
french
because
of
a
title
there.
I,
like
it
next
it'll,
be
in
black
and
white.
E
E
A
D
A
E
That's
kind
of
why
I
like
not
having
the
word
builder
in
it,
because
I
think
your
explanation
is
probably
the
strongest
one
because
basically
builder
implies.
We
know
what
it
builds
right,
because
we
have
to
give
it
the
name
to
the
left
versus
if
we
call
it
interpolator
or
processor
or
handler.
We
just
say
well,
it's
a
protocol
for
a
bunch
of
method,
calls
and
then
as
a
side
effect.
Something
might
or
might
not
have
happened
right
yeah.
It
seems
a
bit
more
easy
to
wrap
your
head
around.
I
guess.
C
A
So
if
fred
doesn't
like
solving
the
er
o-r
problem,
we
can
leave
the
e-d
with
handler.
E
E
A
Like
these
are
the
these
are
the
types
that
will
show
up
in
intellisense,
depending
on
what
the
intellisense
universe
looks
like
for
that.
So
there's
these
and
then
and
then
from
this,
I
think
we
should
pop
back
to
what
do
we
want
to
do
for
the
default,
which
doesn't
have
to
exactly
follow
the
formula
and
then
do
we
want
to
rename
the
attribute
to
instead
of
say,
build
or
say
handler,
because
handler
is
what
we
went
with
elsewhere,
and
so
I
you
know
fred,
I
while
I
like
the
order
that
fred
presented
them
in.
A
E
So
this
is
the
thing
that
yeah,
what
does
it
do,
which
type.
C
Is
it
again,
this
is
the
one
for
string
builder
so
that
you
can
append
format.
You
can
have
your
string
builder,
dot,
append
format
and
interpolated
string
and
it
won't
generate
a
whole
bunch.
E
C
Well,
I
really
don't
want
just
one
word.
I
really
don't
want
that.
So,
what's
wrong
with
the
one
word,
because
what
isn't
what
what
is
an
interpolator?
I
don't!
I
don't
even
know
how
to
associate
that
with
strings
reading.
Looking
at
that
word,
I
don't
that
that
doesn't
say
nothing
about
that
streams.
Interpolate
a
string
to
me.
E
Yeah,
but
I
think
normally
the
the
problem
is,
you
want
to
avoid
conflicts
right
but
like
in
this
case,
we
we
don't
really
care
because
they
are
either
confined
to
compiler
services
or
nested
types,
or
something
right,
and
usually
because
these
are
the
way
these
types
are
constructed.
They
never
appear
by
themselves.
They
always
have
a
very
lengthy
prefix,
based
on
what
the
thing.
C
If
you
want
to
like
try
format
into
an
existing
span
and
interpolate
string
into
an
existing
span
and
that'll
that'll
bail,
if
there's
not
enough,
not
enough
space
in
the
span,
I
think
it's
important
for
these
apis
that
they
actually
have
a
for
that
guy
yeah.
I
think
it's
important
for
these
apis
that
they
say
that
they
have
string
and
some
form
of
interpolate,
I
mean,
and
they
can
sometimes.
A
Like
again,
it's
a
little
weird
being
span
interpolated
string
handler,
but
it's
also
weird
being
spam,
interpolated
string
builder,
but
it's
it
is
a
spanny
interpolated
string
handler.
So
I
think,
like.
A
E
Yeah
I
mean
I
would
just
come.
You
know
suppose
the
you
know
string
interpolator
as
the
middle
ground,
but
if
you
don't
like
that
either
then
I
think
interpolated
string
handler
is
probably
the
best
we
can
do
it
just
feels
really
long,
because
the
thing
is
you
have
now
it's
a
three
word
thing.
That
is
the
thing
you
need
to
combine
with
everything
else
right
so,
like
I
mean
that's,
usually
why
we
like
for
primitives
like
index
and
range
or
span.
E
The
reason
we
went
with
short
names
is
because
we
know
that
we
have
to
combine
these
with
other
things
in
order
to
build
compound
names
right
because
we
have
read-only
span.
We
have
a
span
builder.
We
have
a
whatever.
The
thing
is
right,
and
so
that's
the
same
here
so
like
if
you,
if
you
build
a
convention
for
a
type
name,
that
you
know
you
have
to
compound
with
other
things,
starting
with
a
three
word
thing
really
makes
for
long
type
names.
E
A
Like
the
default
one's
only
going
to
be
called
by
the
compiler,
you
know
99
9,
11
9s
of
the
time
the
default
one's
only
going
to
be
called
by
the
computer,
and
these
other
ones
are
also
really
only
going
to
be
called
by
the
compiler
and
the
like.
We,
we
kind
of
want
intellisense
to
never
show
anyone
these
names.
We
want
it
to
have
some
sort
of
fancy.
C
E
Yeah,
I
was
able
to
say
the
same
thing
I
mean
I
would
desire
that
too,
but
in
pretty
much
in
all
other
cases,
look
at
looking
at
docs
and
other
things.
People
look
at
the
actual
api,
so
I
would
still
hope
we
can
fix
intellisense
to
make
it
a
bit
more
obvious.
But
I
still
think
you
need
to
have
type
names
that
you
can
read
and
still
kind
of,
but.
E
A
F
A
A
A
Like
I
think,
if,
if
fred
really
cares,
that
interpolated
string
be
in
it
as
the
19
letter,
yes,
I'm
aware
that
I,
my
math
is
not
consistent.
Then
then
interpolated
string
handler
is
about
the
shortest
we're
gonna
get.
C
F
C
E
A
I
think
it
matches
from
english
language
perspective,
so
really
it's
fred's
objection.
That
is
the
the
hold
out
on
that
one.
E
A
This
is
the
handler
for
interpolated
strings
on
stringbuilder.pin
format,
and
so
the
previous
proposal
we
came
up
with
was
interpolated
purpose
builder
and
we
all
kind
of
shrugged
and
didn't
like
the
name
but
moved
on
with
life.
And
then
once
the
naming
came
up
for
consideration,
then
I
decided
we
should
care.
I
E
E
E
Well,
it's
basically
the
it's
the
the
basically
between
temple
that
is
string
handler
as
an
atomic
unit
at
this
point
right,
because
it's
basically
the
suffix
for
everything
else
and
I
feel
like
that
seems
very
long
like
if,
if
you,
if
you
have
a
term
that
you
use
always
in
conjunction
with
other
terms,
it
should
really
not
be
a
three
le
a
three
word
thing
right.
It
should
really
be
two
and
maximum.
Ideally
one
right.
E
I
I
still
think
that
length
matters
for
readability
of
concepts
right,
because
you
still
have
to
read
that
name
and
have
to
understand
what
it
does
right
and
the
problem
with
the
previous
ones
were
that,
because
we
had
this
prefix
suffix
convention,
you
reached
the
point.
You
looked
at
the
type
name,
and
you
literally
don't
know
anymore
what
this
thing
actually
does
right.
It's
like
like,
especially
when
we
add
a
default
to
it.
It
was
like
okay,
which
one
is
it
again
like.
Is
that
the
one
that
does
this
thing?
E
A
E
A
E
A
Well,
because
builder
is
the
word
that
was
written
here
in
the
proposal
that
I
highlighted,
so
it
it.
The
compiler
just
turns
the
dollar
sign
syntax
into
these
calls
to
append
formatted
and
append
literal,
using
whatever
arguments
were
correct
for
what
you
had
in
curly
braces
and
if
you're
the
case
of
like
a
log
like
we
have
the
boolean
version,
which
says
I'm
done
working
short
circuit,
like
I've
run
out
of
space,
we
can't
proceed
anymore.
A
A
A
E
A
So
I
think,
with
the
string
builder,
when
we
can
get
away
with
having
the
fact
that
it's
a
nested
type
in
stringbuilder
and
we
can
drop
this
out
of
the
words
if
we
want,
we
could
doesn't
really
matter,
but
we
will
need
for
the
root
one,
a
word
in
front
of
it
and
if
something
like
string
builder
ends
up
with
two
of
them
that
are
not
compatible,
it
would
then
need
to
disambiguate
them
internally
and
since
they're
public.
It
can't
rename
them
once
it
ships.
A
So
it's
probably
better
to
go
ahead
and
always
have
a
purpose
but
yeah.
So
I'm
I
don't
care
across
these
two
emo
prefers
the
shorter
one
and
fred
prefers
the
longer
one,
and
I
need
one
of
you
to.
A
E
J
A
One
is
right
there
yeah,
so
so
now
that,
following
the
name
that
we
just
came
up
with,
that
should
now
be
span.
Interpolated
string
builder
under
system
runtime,
compiler
services,
any.
A
A
All
right
so
now
the
thing
that
if
you
say
that
your
target
type
is
string,
but
you
wrote
the
dollar
sign
syntax.
The
compiler
will
invoke.
Unless
it
decides
it
can't
default.
Interpolated
string
handler
yep.
If
you
have
the
any
convention,
that
would
be
the
outcome.
I
don't
hear
any
cries
and
then
that
means.
C
I
F
Is
it
the
method
info
generic
one.
I
F
F
F
Have
a
whole
lot
of
issues
which
were
about
enough
work,
hopefully,
hopefully
on
tuesday,
we'll
be
done
with
block
finishes.
F
D
A
I
A
F
Was
there
a
there
was
a
question,
an
open
question
in
the
apr
proposal
regarding
interfaces.
Is
that
something
we
don't
want
to
tackle
here.
C
We
can't
tackle
it
at
this
point
and
the
the
so
the
question
was
around.
If
we
still
have
was
if
we
were
still
going
to
support
an
abstract.
If
we
were
still
going
to
support
a
static,
create
method,
then
you
could
make
a
abst.
You
could
make
an
interface
with
an
abstract
static,
create
that
you
then
take
as
a
as
a
constraint
type
parameter
to
a
method,
and
then
you
could
convert
an
interpolated
string
to
that.
C
If
it
had
the
correct,
you
know
if
it
had
all
that,
but
we
then
said
that
we're
not
going
to
support
the
static,
create
method,
we're
just
going
to
use
the
constructor,
and
so
the
question
becomes.
A
All
right,
thank
you,
fred,
for
putting
up
with
my
pet
entry
and
fred
nemo
for
agreeing
on.
I
think.
A
Okay,
so
I
got
that
if
you're
still
on
tarik
sorry,
we
didn't
get
back
to
your
thing,
but
we
had
promised
fred.
This
would
be
an
easy
10-minute
discussion
and
we
should
we
would
just
do
it
pro
forma,
but
instead
we
had
a
long
debate
and
I
think
it's,
I
think,
we're
better
for
it.
So
that's
the
value
of
this
meeting.
E
Tuesday
next
week-
and
I
think
we
should
probably
start
with
carrick's
thing
right
and
then
probably
block
an
hour
for
that
and
then
whatever
the
second
hour
holds
yep.
So.
A
E
Again,
oh
and
next
week
was
the
quarterly
team
meeting
okay,
so
it
means
to
be
next.
If
we
only
have
terrace
thing,
then
on
tuesday
and
then
on,
I
have
to
set
up
another
thing
for
friday,
probably
because
well
it's
the
only
other
day
that
I
have,
because
thursday's
community
stand
up.