►
From YouTube: 2020-05-19 Spec SIG
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
B
E
A
A
H
H
A
So
currently
we
have
like
two
maintainer
surgery
and
Mike
Sergei
left
Microsoft.
Occasionally
he
showed
up
and
how
doing
emerged
on
PRS
Michael
spend
some
time
helping
there,
but
they
were
not
taking
the
full-time
responsibility
for
maintainer
so
like
we
currently
have
Siegel
and
Paolo
acting
as
maintainer.
H
A
So
with
like
Sergei
living
this
life
stuff,
I
were
well
now
like,
like
fully
rely
on
like
a
fewer
number
of
companies
like
Paulo
representing
his
company,
and
we
have
a
few
folks
from
Microsoft
I'm
going
to
add
it
more
developers
there
I
think
for
Don.
Add
we
should
cut
here
coward
soon,
nothing
in
black
buy
enough
June
I
hope
we
can.
We
can
get
her.
We
can
get
her
reasonable,
like
tribulus,
something
like
bit
hard
radius
and
for
another.
A
Sixty
plus
past
I
think
were
definitely
understaffed
currently
because
some
in
turn
from
Google
we'll
see
how
all
right
yeah,
but
definitely
we
need
some
professional
developers
from
other
companies
country
will
only
have
johannes
and
I
feel
folks,
like
spending
very
limited
amount
of
time
from
Microsoft
Wow
I'm
hiring
people.
So
we
should
got
someone
from
like
from
the
Windows
kernel
team
around
like
mid
June
timeframe.
A
A
H
A
Yeah
thanks
I'm
trying
to
see
if
we
can
get
CGI's
the
maintainer
as
soon
as
possible.
He
has
contributed
the
entire
metrics
heart
for
time
to
donate
and
also
he's
working
on
tracing
integration.
Based
on
that,
so
there's
been
contributing
a
lot
and
helping
him
to
be.
The
maintainer
would
accelerate
this
progress
and
how
has
to
ship
the
beta
release
milestone.
H
H
H
H
A
You
don't
need
to
open
a
specific
API
that
will
follow
the
open,
climb,
trees,
bag
and
implement
all
api's
for
you
and
what
we're
working
with
item
we
know
has
one
thing
about:
the
spend
state
has
code,
which
is
very
focusing
on
the
GRDC
code,
although
GRDC
might
do
a
good
made
into
HTTP
status,
but
what
about
other
IQ
or
different
scenario?
So
we
noticed
there's.
One
issue
has
been
like
there
for
like
for
almost
a
year,
and
here
we
have
the
architect
from
Bernard
team
Noah.
In
the
meeting
you
can
see.
A
D
We
want
to
be
as
generic
as
possible.
This
is
not
necessarily
by
the
way
I'm
repeating
myself,
but
this
is
this
was
not
GRDC
defined.
This
word,
Google
statuses,
define,
if
you,
if
you
look,
is
defined
in
the
RPC.
There
is
a
proton
defined
by
Google
and
they
use
these
status
for
for
liberation.
Not
only
for
for
GRDC
we
got
inspired
from
there
again
does
not
mean
that
is
not
limited
to
some
sort,
but
just
a
bit
more
context.
E
Melanie
I
guess
my
my
top
question
might
just
be
right,
like
as
it
is
currently
defined.
What
we
imagine
that
people
want
to
do
with
the
status
property
like,
like
you,
know,
you're
a
you
make
a
you
make
an
instrumentation
tool.
You
have
your
I,
don't
know
web
portal
whatever
it
is.
You
want
to
display
something
like
what
do
we
think
people
would
do
with
status
code?
The
way
it's
currently
defined
so.
D
Because
because
it
has
a
limited
number
of
possibilities,
one
thing
that
one
thing
that
we
did
was
to
emphasize
it,
which
means
which
means
you
you
build
metrics
out
of
the
status
code.
So
so
you
you
want
to
monitor
specific
status
codes.
For
example,
tell
me
whenever
I
hit,
deadline
exceeded
or
or
like
I
I
have
an
operation
that
ends
with
the
non
okay
status.
I,
don't
care
if
he's
deadline
exceeded
because
I'm
fine
with
having
that,
because
I
have
retrying
and
stuff
like
that.
So
so
it's
more
like
it's,
at
least
in
Google.
D
I
C
I
Is
another
thing
I
think
we
had
some
semantics
for
this
and
open
tracing
but
I
think
that's
still
an
open
issue
and
open
telemetry
is
how
precisely
to
define
errors
and
exceptions,
which
is
a
little
bit
different
from
this
status
code.
But
in
my
mind,
that's
that's
the
part.
That's
a
little
more
critical
and
what's
missing
from
our
semantic
conventions
right
now,
so
I
just
wanted
to
flag
that
that
I
don't
think
the
status
code
is
necessarily
like
a
substitution.
I
I
D
Exception
is
not
in
there
oh.
By
the
way
I
mean
there
are
semantics
that
are
not
and
so
on.
So
it's
very
bad.
This
scenario
anyway,
what
I'm
trying
to
say
is
at
least
with
these
status,
what
Google
did
I
no
longer
part
of
Google,
but
what
Google
did
was
define.
Even
errors
were
defined
by
the
the
status,
the
status
code
now
I
think
I
think
we
can
go
with
a
very
generic
thing
and
say:
hey.
D
You
know
what
we
just
have
a
boolean
called
error,
and
if
the
user
says
this
is
an
error,
we
don't
care
whatever
error.
It
is,
we
just
say
it,
but
the
problem,
the
problem
that
you
have
is
who
is
defining?
What
is
an
error?
Who
is
who?
Who
defines
that
this
is
an
error?
This
is
not
an
error,
and
this
is
very
important
when
it
comes
to,
for
example,
in
dotnet.
If
you
are
writing
an
HTTP
integration,
so
you
create
some
spans
every
time
and
when
a
HTTP
requests
start
with.
I
Think,
maybe
you
need
to
decouple
learning
from
reporting
here
right,
like
there's
reporting
these
things
in
some
like
standard
way,
that's
possible
and
expected
like.
Where
do
you
put
an
exception
or
a
stack
trace
or
an
error
message
from
a
user?
If
you're
not
talking
about
exceptions
or
something
like
an
HTTP
status
code,
there
has
to
be
like
some
way
to
define
these
things
that
somewhat
standardized
at
least
around
all
these
common
cases,
whether
or
not
you're
trying
to
alert
on
these
things
or
do.
I
It
that
I
agree
at
the
end-user,
like
it's
not
automatically
true,
that
you
care
about
400
status
codes
from
a
particular
end
point,
whereas
you
might
really
care
about
it.
Another
end
point
but
I
think
that's
more
like
a
back-end
alerting
issue,
not
a
question
of
how
do
you
describe
these
things?
Yeah.
J
I'd
like
to
point
out
that
sometimes
the
same
event
can
be
considered
an
error
or
not
an
error
by
different
parties
in
a
distributed
transaction
so
like
to
me
that
was
a
normal
failure.
I
don't
want
to
see
an
alert,
but
to
you
that
was
an
error
because
you
didn't
expect
it.
So
it's
like
much
more
like
common
that
you
see
both
interpretations,
I'd,
say
yeah.
I
E
So
by
I
mean
I
sort
of
give
you
a
little
context
of
my
concern,
but
you
know
my
concern
is
that
will
wind
up
creating
space
for
many
different
things
and
every
span
according
to
the
design,
is
expected
to
have
a
status
and
for
some
things,
I
think
we've
made
this
the
expected
status
relatively
clear,
like
if
I'm
doing
a
you
know
a
G,
RPC
message
or
I'm
doing
an
HTTP
request.
I
think
we
have
pretty
clear
conventions.
E
I
E
What
I'm
curious
is
you
know
if
we
take
something
that
isn't
a
HTTP
or
a
G
RPC
request?
I
mean
let's
say
it's
a
it's
a
span
I
mean
just
to
be
arbitrary.
It's
a
span
that
involves
calling
a
win32
api
and
getting
an
H
result
back.
Something
that's
nothing
like
you
know,
HTTP
or
G
RPC,
and
that
comes
a
particular
H
result.
E
D
I
will
start
I
would
start
a
bit
higher
level.
Do
we
all
believe
that
the
sides
of
the
canonical
parts,
the
the
the
errors
that
we
defined
the
codes
that
we
define,
do
we
all
believe
that
having
status
is
useful
on
the
span
or
not
decide
like
we
can
redefine
how
it's
designing
is
the
structure,
but
I
was
more
canonical
question
yeah.
E
G
You
know
I
mainly
look
at
it
for
four
operational
monitoring
so
and
but
that
a
mainly
applies
to
remote
calls.
I
mean
you
know,
read
you
know,
their
requests,
airs
and
durations
I
need
to
know
how
many
errors
I'm
getting
and
what
kind
of
errors
they
are,
but
that
mostly
applies
to
remote
I
mean
that
just
applies
to
remote
calls.
If
you
know
it's
something
internal
to
the
program
and
that
probably
doesn't
make
any
difference
as
far
as
running
the
same
production.
D
D
I
think
we
have
to
first.
In
my
opinion,
we
have
to
first
answer
this
question:
do
we
want
to
see
these
status
of
operations?
Do
we
believe
it's
important
to
have
it?
Maybe
maybe
maybe
maybe
the
other
answers.
Kimmie
said:
maybe
some
of
the
operation
habits
that
to
some
don't
sure
and
that's
a
fine
answer
and
that's
something
that
we
can
we
can
adjust
for
that
right,
so
I'm
like
now,
based
on
your
experience,
I
would
like
to
hear
things
and
understand
better.
What's
your
position
and
what's
your
recommendation
so.
E
I
mean
part
of
it
as
I
was
trying
to
you
know,
let's
say
tread
carefully
just
because
I
can't
necessarily
find
a
use,
for
it
doesn't
mean
that
other
people
don't
have
a
use
for
it.
So
I
wanted
to
attempt
to
learn
what
other
people
might
want
before.
I
made
any
suggestions,
assuming,
for
example,
that
we've
decided
the
status
is
actually
something
that
is
useful
for
a
category
of
spans
but
is
not
useful
for
necessarily
every
span
like
if
we
say
that
it's
something
that
network
operations
tend
to
have
but
non
network
operations.
E
A
I
Like
just
starts
to
become
difficult,
we
have
another
attribute.
That's
like
span
type
that
has
like
a
similar
issue
around.
This
is
an
HTTP
span,
or
is
this
like
a
database
span
but
walking
to
a
database
over
HTTP?
You
know
then
like
which
span
type
do
I
choose
and
so
in
general,
I.
Think
having
like
these
composable
semantics
of
like
just
saying
this
is
a
network
request.
Here's
the
protocol
information.
I
There
is
an
exception,
so
I
logged
the
exception,
using
the
exception,
semantics
I'm
reporting
a
stack
trace
so
I'm
doing
that
formatted
according
to
how
we
do
it,
blah
blah
blah,
wait,
I,
think
composing.
These
things
to
do
together
is
generally
more
useful
as
far
as
describing
things
one
place
where
I
have
seen
this
in
particular,
something
like
the
status
code
be
useful
for
which
could
be
replaced
with
semantics,
but
it
is
simple,
is
around
things
like
triggering
trace
collection,
so
in
particular,
if
you're
doing
tale
based
sampling,
you
know
you
you
care
about
outliers.
I
Quite
a
bit
and
one
form
of
outliers
are
errors
and
exceptions,
or
you
know
unusual
spans.
So
something
like
a
status
code
just
is
like
a
general
warning
sign
that,
like
this
is
an
unusual
span.
This
fan
there's
not
okay,
it's
not
doing
its
normal
thing,
it's
doing
something
strange,
and
so
you
might
be
interested
in
it.
That,
to
my
mind,
is
a
use
for
this.
The
status
code,
I
think
I
think
you
could
do
it
in
a
different
way,
but
that
is
like
a
useful
thing
that
I
see
people
doing
but
I.
D
The
fact
that
for
for
especially
in
the
microsystem
world,
whenever
you
do
an
RPC
call,
you
need
to
know
if
the
remote,
the
RPC
call
was
successful
or
not,
or
if
you,
if
you
got
an
error,
then
probably
something
is
wrong
in
99%
of
the
times
when,
when
we
deal
with
micro
services
and
we
get,
we
don't
get
the
result
from
the
service,
we
get
that
line
exceeded
or
whatever
permissions
being
either
all
these
errors.
It
will
be
super
useful
for
for
the
devil
to
know.
This
know.
C
D
The
operation
is
not
OK,
and
if
you,
if
you,
if
you
have
ever
monitored
like
micro
services
things,
you
will
figure
out
that
usually
any
kind
of
error.
It's
is
bad,
so
you,
you
probably
most
likely
gonna
kind
of
set
up
an
alert
and
say
if
the
operation
is
not
OK
I
want
to
now.
There
is
an
arguably
question
and
in
the
I'm
fine
thinking
that
this
may
be
semantics
conventions.
D
I
Praise
it
a
little
bit
differently
if
you
look
at
the
status
codes
that
are
offered
all
the
ones
that
have
a
specific
definition
do
so
because
they're
there,
generally
speaking,
those
are
all
scenarios
where
you're
dealing
with
some
kind
of
protocol
and
if
you
put
that
protocol
information
down
on
this
fan,
you've
also
should
be
capturing
this
information.
So
things
like
you,
know,
cancel
deadlines
exceeded,
or
you
know,
permission
denied
a
lot
of
these
things
to
me.
Sound
like,
as
Noah
mentioned
there,
they're
really
mostly
related
to
network
operations
and
those
network
operations
or
protocols.
I
I
G
D
Having
class
of
errors,
the
way
how
we
have
it
right
now
defined
by
the
status
is
variable
and
trying
to
map
as
many
protocols
to
this
canonical
error
codes
is
very
useful
for
not
only
for
DevOps,
probably
for
for
vendors
to
be
able
to
not
have
to
deal
with
any
new
shiny
protocol
that
that
appeared.
That
being
said,
it
does
not
give
a
plus
or
minus
to
the
fact
that
this
is
inside
an
attribute,
or
this
is
a
separate
field.
Still
if
we
go
with
this
definition
of
hey,
these
are
the
possible
errors.
D
D
From
your
perspective,
all
the
advantages
that
we
have
a
predefined
list
and
everything,
fine
and
I'm
hundred
percent
on
this
I
think
I.
Think
Noah's
point
is
not
to
remove
this
classification
or
this
semantic
convention
is
more
like.
He
would
like
to
remove
the
first
class
if
you
design
code
status
and
move
it
to
the
attributes.
Yes,
yes,.
B
Mean
one
drawback
of
the
current
statute
is,
in
my
opinion,
that
the
default
is
okay.
So
if
you
don't
care
to
set
the
status,
it
will
be
okay,
and
you
can't
really
distinguish
if
it
was
really
okay.
If
there
was
no
mapping
analyst
and
not
sure
if
we
have
unknown
error,
if
it's
unknown,
but
maybe
there
is.
D
Can
be
change
and
even
if
you
define
semantics
conventions-
and
let's
say
you
say,
user
for
every
HTTP
span,
you
have
to
define
the
status
attribute
or
or
think.
If
the
user
does
not
define,
what
does
it
mean?
It
means
okay
or
it
doesn't
mean
I
mean
we
still
have
to
to
make
an
interpretation
of
user
being
lazy,
not
setting
that
what
do
we
do
like
yeah.
D
Think
that's
a
small
change
in
our
current
thing.
I
think
there
is
a
line
in
the
specs
that
says
if
the
user
is
lazy,
just
say
start
with
this.
Okay,
we
can
change
that
line
and
say
status
is
unknown
or
unset,
but
I
think
know
is
more
deeper
thing
and
by
the
way,
don't
get
me
wrong.
That's
that's
a
good
clarification
and
we
can
discuss
that
if
we
decide
to
stay
with
status.
What's
the
default
behavior
when
I
I
think
the
dominant
theme
is
looking
for
a
different.
C
C
This
bank
should
know
exactly
what
what
to
do
with
the
status
and
how
to
handle
it,
how
to
set
it,
how
to
read
it
and
in
some
time
I
bought
like
you
know,
if
we
need
to
think
from
what
I'm
seeing
is
like
you
know,
we
don't
have
like
a
generic
story
about
like
satisfy
everyone
here
and
you,
like
you
know,
for
for
like
no.
This
is
my
scenario,
and
this
is
my
status
and
other
scenarios,
and
so
on.
C
So
from
my
point
of
view
about,
like
you
know,
if
you
need,
if
you
need
to
go
with
the
status,
we
should
have
more
generic
one,
which
is
allowed
like
a
provider
mechanism
or
a
provider
pattern
which
is
like
you
know.
We
never
know
about
like
what
scenario
we
come
in
the
future,
and
this
would
be
the
status
for
this
right,
and
so
this
should
be
kind
of
like
a
way
to
plug
in,
like
you
know,
extend
this
status
notion
and
get
more
information
about
this
scenario.
D
Ssin
of
error
class
there
was
a.
There
was
a
third
field
called
ever
class
that
didn't
move
because
everyone
defined
their
or
their
own
error
classes
and
the
whole
stat
was
lost
its
its
property
of
being
being
able
to
to
understand
across
different
components,
so
so
the
whole
the
whole
problem
that
Kevin
mentioned,
which
was
like.
D
It's
it's
I'm,
going
to
define
mine
I'm
better
than
whatever
these
guys
did
and
giving
that
flexibility
sometimes
lead
to
to
to
a
wild
world
where
it's
going
to
be
very
hard
for
somebody
that
is
monitoring
or
using
these
informations
to
make
use
of
that
like
alerting
and
stuff
to
consume
the
data.
So
so
you
have
to.
We
have
to
carefully
understand
that
if
you
open
the
world,
everyone
will
do
and
trust
me.
You
probably
know
very
well
as
what
net
every
API
that
will
expose
people
will
abuse
them.
So.
D
C
Not
suggesting
to
get
rid
of
status
I
mean
just
to
be
clear,
and
you
know
my
my
suggestion
is
like
we
should
have
more
generic
way
and
in
like
everyone,
can
define
their
own
status
and
it
would
be
well-defined
for
this
scenario.
I
mean
like
for
HTTP,
we
can
say
about
like
you
know,
the
provider
is
called
like
HTTP,
and
this
is
the
error
codes
for
HTTP
yeah
and
for
other
scenario,
to
be
like
sequel,
devs
or
something.
This
is
the
signal
database,
and
this
is.
I
How
we
define
all
of
the
attributes?
So
if
you
have
HTTP
there's
a
definition
for
all
the
attributes,
you
should
set
to
properly
define,
say
an
HTTP
client
span,
and
so,
if
you
had
say
like
a
new
protocol,
let's
say
it's
a
proprietary
protocol.
So
no
one
outside
your
company
knows
about
it.
You
could
define
a
new
semantic
convention
for
how
that
protocol
would
work
and
then
add
those
attributes
onto
spans
that
are
operating
on
that
protocol.
So
it's
extensible
in
that
respect.
I
The
thing
is
no,
let's
say
no
generic
monitoring
back-end
knows
about
your
proprietary
protocol,
so
they
can't
key
off
of
these
new
semantics
because
they're
not
super
common.
That
would
be
a
case.
We're
also
setting
some
more
generic
status
code
to
something
like
error
or
you
know,
unavailable
or
canceled
might
be
helpful,
because
that's
a
known
list
that
that
may
be
able
to
trigger
behavior
that
your
your
unknown
additions
wouldn't
be
able
to
trigger
without
some
manual
work.
E
So
so
I
was
hoping.
I
know,
there's
probably
a
lot
of
diverse
opinion
when
we
go
into
like
what's
what's
the
proper
representation
of
errors,
and
so
I
was
hoping
to
dodged.
That
bullet
by
by
basically
just
saying,
is
there
some
level
of
agreement
that
status
as
it's
currently
defined
doesn't
actually
apply
to
all
spans?
And
then
assuming
that's
true?
E
How
do
people
feel
about
basically
saying
instead
of
status
being
a
top-level
API
on
span
status
is
going
to
be
represented
as
a
semantic
convention
for
the
set
of
spans,
where
we
currently
believe
it
makes
sense,
and
it
will
have
exactly
the
same
meeting
for
those
spans
that
it
currently
does
we're
just
sort
of
taking
it
away
from
the
other
spans
where
we
actually
don't
have
a
good
definition.
The
value
at
map
status
today.
D
C
D
D
D
C
K
No,
no
I
I
think
that
I'm
a
little
concerned
about
removing
the
span
status
or
spans
the
first
class
from
an
as
a
first
class,
feel
just
from
the
fact
that
you
know
I
think
if
there's
gonna
be
edge
cases
where
it
may
be
a
little
gray
as
to
how
to
apply
it
or
it
may
not
be
a
clear
understanding
how
to
apply
it.
But
if
you're
not
hitting
like
the
95
percent
or
maybe
even
the
99
percent
of
cases,
that
you
will
actually
have
a
good
reason
to
have
this
fan
status.
Go
there.
K
A
lot
of
the
users
are
going
to
be
very
confused.
Why
we
don't
support
that?
What
a
lot
of
the
back
ends
that
we're
sending
these
fans
to
do
have
some
sort
of
idea
of
the
status
and
have
a
very
good
understanding
of
like
what
that
actually
should
look
like
in
many
cases.
It's
also
considered
a
first-class
status,
so
just
a
little
bit
about
hosed,
but
I
am
hesitant
of
the
idea
of
having
a
minor
edge
case
lead
the
design
decision
for
the
majority
of
use.
K
Cases,
I
think,
is
an
important
thing
to
keep
in
mind
with
that
said,
the
proposed
idea
to
make
it
more
of
a
generalized
status
and
not
have
it
locked
down
to
G
RPC
codes
seems
like
a
functional
change
that
could
be
for
the
better,
especially
if
it's
going
to
be
more
inclusive.
I
do
think
that
the
GRC
stuff
is
it
it's
a
world
view
that
I
think
is
it's
somewhat
narrow
in
many
cases,
but
I
think
that's
also
going
to
be.
You
know,
that's
where
spans
were
born
from
I.
K
E
So
it's
interesting
to
hear
you
refer
to
it
as
a
edge
case
and
I
guess
it
all
depends
on
a
frame
of
reference
like
in
my
imagination,
when
I
think
of
most
like
most
dotnet
developers,
anytime,
that
they
would
encounter
this
span
API
or
what
is
likely
to
be
an
activity
API
and
dotnet.
The
reason
that
the
developer
is
encountering,
it
probably
already
means
it's
not
a
it's,
not
an
HTTP
request
and
it's
not
an
RPC,
because
if
it
was
like
the
libraries
that
do
HTTP
and
RPC
it
would
just
do
it
for
you.
E
You
wouldn't
even
need
to
think
about
it.
So
if
you
as
a
developer,
actually
writing
it
yourself,
then
it
means
it's
some
operation
that
you
are
doing.
That's
not
HTTP
or
G
RPC,
it's
something
else,
and
so
I
would
imagine,
in
the
majority
of
cases
that
you're
doing
something
else
that
that
those
developers,
they're
gonna,
say
status.
What
what
do
I
do
with
this
and
they're
just
gonna
sort
of
shrug
and
they're,
probably
gonna,
say
I
I,
don't
know.
I
I
have
this
exception.
E
J
I
Think
there's
a
funny
middle
ground
I,
do
see
where
you're
saying
no
and
we've
encountered
this,
which
is
what
happens
with
someone
says.
You
know
segfault,
you
know,
or
serious
exception
and
stacktrace
span
status.
Okay,
like
would
you
know
if
all
of
that
information
is
stapled
on
to
a
span,
but
then
they
don't
change
the
status
sic
form
by
the
way
you're.
D
D
E
D
D
D
E
Exception
looks
like
a
good
mapping,
I've
gotten
exception,
so
they
go
ahead
and
they
set
that
and
then
my
question
will
be
have
we
generated
something
that
is
useful
at
the
back
end,
because
part
of
the
question
to
start
with
was
I.
Don't
really
necessarily
know
what
people
want
to
do
with
the
with
the
status
code,
and
we
may
have
just
made
some
ambiguity,
like
maybe
maybe
you'd
say.
Oh
man,
that
was
a
timeout
exception.
E
I
wish
you
had
mapped
that
to
the
deadline
exceeded
enumeration
and
not
to
the
language
exception
enumeration,
but
it's
gonna
depend
on
what
the
usage
is
at
the
back
end
and
what
the
expectation
is,
and
since
we
haven't
really
defined
it
for
anything
that
isn't
an
HTTP
request
or
a
G
RPC
call,
then
it
could
quickly
be
the
Wild
West,
where
everyone
just
sort
of
makes
their
own
guess
as
to
how
they
think
it
should
and
and
and
no
one's
doing
it.
The
same
way
so
I
mean
that's.
Some
of
my
concern
is
like.
L
D
Some
sort
of
this
thing
and
then
and
then,
because
what
I'm
hearing
is
you
know
what
was
the
exception?
I
would
like
to
know
what
kind
of
exceptions
what
the
type
of
the
exception
was
not
only
not
only
that
it
was
an
exception.
It
may
not
be
enough,
and
even
though,
for
example,
it
was
a
timeout
exception,
which
is
a
separate
thing.
The
fact
that
I
know
it's
a
timeout
exception.
Then
then,
by
having
specific
classes,
we
can
make
a
translation
between
classes,
that
user
can
control
and
stuff
like
that.
D
K
H
I
D
D
The
goal
I
think
the
effect
that
is
there
is
commune
dependent
of
the
probability
sample
algol
in
the
the
first
four
are
related
more
to
the
the
probability
sample
are
green.
The
the
fifth
one
is
about
propagating
the
the
probability
that
you
use
on
the
wire
and
different
I
would
say
it's
a
different
beast
and
a
different
topic
which,
which
I
I'm
happy
to
keep
them
separate.
D
H
H
F
F
D
F
F
D
F
D
D
I
think
George
did
a
good
job
and
every
time
when
we
we
have
a
bunch
of
people
with
metrics
expertise
approving
that
PR,
even
though
the
approval
counts
or
not
count,
that's
a
separate
issue,
but
prove
it,
which
means
please
they
looked
at
that
and
they
say
something
but
did
not
have
the
feeling
from
loss.
It.
F
J
Like
to
say
on
the
record
that
I
am
upset
because
the
open
telemetry
Charter
when
I
joined
the
project
was
spans
and
metrics,
and
right
now,
I
want
us
to
finish.
The
spec
I
want
1.0
to
be
shipped
before
anyone
talks
about
logs,
because
it's
slowing
us
down
it's
not
that
I'm
upset
about
the
actual
idea
of
logs
I
love
the
idea
of
logs,
but
we're
slowing
ourselves
down
with
it
and
I
think
we
should
hit
one
point
now.
H
J
F
It's
not
the
general
sentiment
that
we
don't
want
to
do
the
logs,
because
if
that's
the
case,
we
will
need
to
be.
We
need
to
be
clear
about
that.
Lots,
there's
lots
of
expectation
from
people,
especially
who
are
not
open,
telemetry
contributors
or
not
members
I
think
we
welcome
them.
But
now
we
don't
seem
to
that's
the
case.
Let's
be
clear
about
that.
M
I
I
Like
Josh
just
sorry
sorry
Bogdan
I,
it
would
be
great
to
get
I
think
just
from
talking
to
you.
I
think
it's
in
particular
like
collectors
support
for
metrics,
but
I.
Would
we
don't
have
to
solve
right
now,
but
I
would
look
to
work
with
you
to
get
a
like
a
concrete
list
of
what
what
has
to
get
in
there
for
metrics
to
to
GA,
so
that,
like
there's
natural
issues,
and
that
we
can
like
push
on
to
make
sure
they
get
prioritized
right.
J
D
I
would
personally
say
by
the
way
I
open
it
twice
that
PR
and
because
of
the
fact
that
it's
another
300
lines,
I
was
always
top
that
as
a
small
thing,
smaller
PRS
are
easier
for
review.
At
least
for
me,
we
have
a
meeting
to
move
forward
with
the
proto
problems.
I,
don't
think
I,
don't
see,
metrics
being
stopped,
I
think
in
Java,
I
almost
finished
the
matrix
API,
so
I
think
everyone
is
focused
on
that.
D
F
C
M
Want
to
keep
part
of
uplands
lemon
tree
and
I.
Think
logs
is
very
important
for
them,
and
I,
don't
just
mean
I
was
on
here,
like
sumo,
is
part
of
this
elastic
like
there's
a
lot
of
other
vendors
that
we
want
to
get
involved
in
everything
else
who
are
getting
involved,
starting
because
of
logs
I
wish
to
balance
that
against
what
Josh
brought
up
is
potential
slowdowns
to
things
like
the
metrics
bang
I.
Think
right
now
like
we
need
to
be
all
hands
on
deck
for
metrics
in
particular,
but
I.
H
F
M
Need
to
be
clear,
but
I
I,
don't
I
I
agree
like
like
I,
think
Josh
or
someone
had
mentioned
like
there's
some
contributors
like
Yuri,
who
is
limited
time
and
some
of
that
time
is
shifted
to
logging
and
for
this
phase
the
project-
that's
probably
not
good,
but
I
I
think
we
can
still
strike
a
balance
here.
Yeah.
F
M
J
Don't
think
so,
but
I
just
I,
don't
know
when
well,
1.0
comes
I,
just
I
want
it
to
come
quickly
and
so
I
just
I
feel
like
then,
as
we
began,
this
meeting
Riley
was
saying:
there's
not
enough.
Professionals
contributing
I,
think
that
that
is
that
the
case
here
and
so
the
more
we
spread
ourselves
around,
the
less
we
get.
Okay
can.
L
J
The
other
I
mean
opinion
I
have
is
just
that
like
there
are
two
ways
we
could
look
at
logging.
One
is
it's
an
ingestion
problem
where
we
want
to
bring
in
a
bunch
of
structured
data,
that's
going
to
be
put
into
the
stream
of
observability,
and
that
is
like
what
we're
currently
working
on
and
the
second
way
you
could
look
at
logs
is
there's
a
desire
to
have
a
standard
API
like
we've
done
with
tracing
and
metrics.
It
is
how
a
user
is
going
to
integrate
logging
into
their
framework
into
their
application
into
their
libraries.
J
So
on
we
haven't
gone
that
far
and
I.
Think
it's
good
that
we
haven't
gone
that
far,
but
the
open
telemetry
model
was
we
were
going
to
standardize,
api's
and
so
I
think
it
would
be
a
very
appropriate
to
say
open.
Telemetry
2.0
will
contain
logging,
API
and
you're
gonna
need
that
data
representation.
First,
when
we
went
into
tracing
we
had
a
backwards
compatibility
story
for
open
tracing.
We
would
have
to
have
a
backwards
compatibility
for
all
the
logging
frameworks
out
there.
It's
just
a
huge
project
and
I've
seen.