►
From YouTube: 2022-06-15 meeting
Description
cncf-opentelemetry meeting-2's Personal Meeting Room
A
B
D
Okay,
let's,
let's
get
started.
D
D
Quick
update
on
a
couple
things
that
happened
last
week,
one
I
went
to
the
log
stick
with
santosh.
There
was
a
further
discussion
on
the
shape
of
the
events.
Api
and
decision
was
made
to
combine.
Well,
I
think,
even
if
you
were
there
too,
the
decision
was
made
to
to
combine
to
have
a
single
single
api
for
both
logs
and
events.
D
And
then
the
other
update
is
nav.
That's
your
your
issue
for
that
with
the
new.
E
That's
not
a
dumb
question,
so
simplistically
logs
could
be
anything
including
like
debug
logs,
where
events
are
really
individual
things
that
are
that
occurred,
so
lots
of
people
treat
logs
and
events
or
lots
of
different
api
streams,
blogs
and
events
the
same
thing.
So
there
is
a
very
fine
difference
between
them,
mostly
for
back-end
servers
for
the
client,
and
we
tend
not
to
worry
about
logs.
We
just
send
like
custom
events
with
debug
information,
so.
E
But
we
were
voted
down,
so
it's
going
with
a
combined
one
for
now
on
the
basis
that
maybe
it'll
change
in
the
future,
because
yeah
like
while
client
like
for
a
browser,
we
probably
want
to
have
the
ability
to
write
a
log
lots
of
things
like
java
and
that
point
it'll
only
be
the
appenders
that
will
be
using
the
log
api.
D
Okay,
I
guess,
martin
from
from
the
shape
of
the
difference
of
the
shape
of
the
data
between
login
event.
Event
has
a
name.
We
always
have
a
name
also
per
the
for
the
events.
Api
spec,
it's
going
to
have
a
domain,
so
the
combination
of
domain
and
name
will
identify
uniquely
the
the
event,
whereas
logs
don't
have
a
name
and
logs
also
have
things
like
the
severity
fields
which
typically
don't
apply
to.
D
Okay,
so
I
what
I
would
like
to
do
like
yesterday,
we
we
started
talking
about
semantic
conventions
for
timing
events,
and
I
would
like
to
continue
that
discussion
a
little
bit.
Does
anyone
have
any
other
topics
for
today
before
we
get
into.
E
It
I
was
going
to
ask
you
to
drop
a
link
to
the
doc
from
yesterday,
because
ram
was
looking
for
it,
but
the
new
one
looks
like
it's
probably
better
anyway,
or
a
continuation
of
this
one.
D
Okay,
so
let
me
share
my
screen.
D
D
So
I
went
through
I
I
started
by
going
going
through
the
w3c
api
for
the
performance
observer
performance
entry.
So
all
these
things
like
navigation
resource,
you
know.
Actually,
if
you
look
at
this
table
like
these,
these
column
names,
the
top
represent
the
different
types
of
events
or,
I
guess
performance
entries.
D
You
can
get
from
the
api
things
like
paint,
large
content
of
paint,
element,
timing,
user,
user
timing,
long
task
and
so
on,
and
I
listed
some
some
the
attributes
that
they
that
these
things
have
on
them
that
they
provide.
D
The
name
kind
of
varies
depending
on
the
the
type
of
the
the
entry
and
then
the
start
is
the
relative
timestamp
relative
to
the
navigation
start
pretty
much.
All
of
them
have
it.
The
navigation
has
a
zero
because,
because
it
starts
at
zero,
so
and
then
then
some
of
them
share
attributes
some
of
them,
but
some
of
them
a
lot
of
them,
have
unique
attributes
based
on
based
on
the
type
there.
Also.
I
also
listed
them
down
here.
D
D
So
and
then,
then
we
started
talking
about
like
the
shape
the
shape
of
the
elements,
I'm
going
to
jump
really
quick
to
to
well
actually
yeah
to
this.
To
this
other
dock,
where
we
have
started
to
like
draft
the
the
spec
we
talked
about
like.
I
think
this
was
maybe
you'd.
Never
you
can.
You
can
correct
me
here,
like
if
I
captured
this
correctly,
but
one.
The
first
thing
that
we
would
need
to
do
is
define
the
the
semantic
conventions
for
the
event
generic
fields
or
attributes.
D
So
we
we
already
talked
about
domain
name
field
is
obvious.
This
description.
We
also
talked
about-
and
I
added
this
data
event.data
attribute,
which,
which
could
be
any
any
any
type.
The
intent
here
is
that
some
some
domains
may
choose
to
send
the
event
specific
attributes
in
this
attribute.
D
That
could
be
as
as
an
object
or
it
could
be.
Perhaps
a
serious
string
does
that
align
kind
of
what
you
were
thinking
enough.
E
Yeah,
probably
the
only
thing
I'd
say
instead
of
saying
any
reaction
when
I
say
attribute
to
link
with
the
because
it's
not
like
any
object,
it'll
actually
be
nested
attributes,
so
in
an
attribute
can
have
a
have
an
attribute
as
its
child.
Do
we
have
a
link
for
this
stock
in
the.
D
Yes
right,
this
dislike
this
tag
should
be
yeah.
That's
this
one!
It's
not
the
convention,
okay,
yeah
and
I
mean
I
can.
This
is
just
a
draft
document
for
for
this
discussion.
Like
I,
I
wasn't
sure
if
I
wanted
to
like
keep
this
document.
I
just
wanted
to
use
it
for
the
decision,
but
I
can
also
put
it
right
here.
If
you
want.
E
Oh
yeah,
I
I
guess
the
only
other
thing
that
we
talked
about
was
because
we
have
a
name
and
name
was
going
to
be
timing.
Do
we
want
to
have
a
separate
event.type
so
effectively?
The
combination
of
domain,
name
and
type
would
qualify
the
the
expected
or
do
do
we
just
want
to
say
the
the
table
that
martin
had
earlier
with
all
the
performance
timing.
Just
do
we
just
want
to
say
timing
is
like
optionally
all
these
fields.
I
guess
that's
one
of
the
questions
get
feedback
from
everyone
here.
E
D
Yes,
so
so
the
yeah
I'll
stick
up
like
a
few
options
here
of
what
that
event
would
look
like
I
mean
it,
it
could
be
if
we
followed.
Let
me
just
go
back
here.
D
Okay,
so
so
like
yeah,
I
just
I
just
gave
this
as
an
example
like.
So
there
is
a
base
class
for
performance
entry
and
then
like,
for
example,
the
resource
timing,
extends
that
and
then
the
navigation
timing
extends
that.
So,
if
we
we
could,
you
could
model
this,
as
one
option
is
having
one
single
event
type.
D
That's
maybe
like
something
like
you
know,
like
event,
name
would
be
timing
and
then
you
would
have
you
would
have
all
the
different.
D
You
know
possible
attributes
that,
based
on
the
type
of
the
entry,
so
I
think
this
this
thing
has
entry
type,
which
is
which
is
which
is
an
enumeration
of
the
different
types
of
the
the
performance
entries.
D
D
The
option
two
would
be
would
have.
The
event
name
actually
would
be
based
on
the
subtype.
So
event
name
would
be
for
paint
for
navigation
largest
content
propane.
D
All
these
things
would
have
a
different
event
name
and
then
the
data
would
be
so
then,
in
the
semantic
conventions,
we
would
have
documents
for
all
these
different
types
of
events
unlisted
the
attributes
that
they
that
they
have
then
then
option
three
I
was
I
was
thinking.
D
There
are
a
lot
of
shared
fields
and
the
like.
The
navigation,
for
example
like
if
you
think
about
the
navigation
event,
it's
it
has
fields
that
represent
different
things.
So
it
has.
It
has
you
know
it's
navigation,
specific
attributes.
It
has
specific
attributes
that
inherits
from
the
resource,
and
it
has
like
the
common
timing
attributes
like
start
time
and
duration.
D
So
the
way
we
could
also
do
it
in
the
spec
is
have
semantic
conventions
for
for,
like
the
the
type
of
type
of
attribute.
So
it
would
be
like
navigation
resource
attributes,
timing,
attributes
and
then
then,
like
in
the
semantic
conventions
for
the
type
of
event
we
would
list
which
ones
which
ones
they
that
event
uses,
and
that
would
allow
us
to
share
share
attributes
among
different
events.
D
So
you
wouldn't
necessarily
duplicate
them.
D
F
I
think
there's
there
might
be
an
option
for
here,
so
the
the
w3c
spec
kind
of
specifies
several
data
bottles
as
you've
observed
performance,
mark
performance
measure,
nav,
timing,
resource
timing,
paint
timing.
F
Each
of
those
could
potentially
be
event
names
as
well
and
then,
like
the
contents
of
this,
will,
like
the
the
schema,
would
match
those
classes
or
the
data
models
as
closely
as
possible.
Does
that
make
sense.
E
It's
like
yeah,
I
think
that's
option.
One
building
this
one
apart
from
we've,
got
type
instead
of
entry
type.
F
D
Yeah,
so
I
think
that
they're,
it
kind
of
boils
down
to
like
the
two
things
for
me,
like
how
broad
the
event
name
should
be
so
like,
like.
I
have
in
these
two
examples.
I
have
like
event,
name
being
the
specific
event
type
and
like
in
the
option
one.
I
have
it
like
the
broad
timing
and
then
the
other
question
is
in
in
like
should
we
should
we
do
like?
D
D
I'm
just
I'm
just
I'm
just
thinking
how
to
organize
this
in
the
in
the
semantic
dimensions,
yeah
and-
and
I
was
thinking
like
the
the
pattern,
the
current
pattern
for
semantic
conventions
is
that
you
can
compose
compose
different
sets
of
attributes.
D
You
know
to
a
signal,
so
a
signal
can
represent
multiple
things.
Essentially.
E
Yeah,
I
I
I
mentioned
it
yesterday.
I
I
don't
think
we
wanted
to
do
that
with
events.
I
think
we
want
to
define
events
as
a
discrete
thing
rather
than
okay.
Okay,
I
oh
the
word
just
keep
me
rather
than
a
a
composed
event.
You
just
say
you
know
this
is
this.
Is
this
event
and
then
that
that
event
has
these
sets
of
attributes
and
optional?
D
C
E
That
yeah,
there
is
an
argument
like
at
the
moment
for
app
insights.
We
spit
out
both
a
page
view
and
a
page
view,
timing
event.
So
where
I
thought
you
were
going
with
option
three
was
we
actually
have
an
event
and
then
effectively
the
first
level.
Sub-Objects
would
be
the
the
composed
elements
if
you
like,
but
I
think
in
terms
of
a
navigation.
A
navigation
event
has
affected
the
combination
of
the
resource
and
the
navigational
fields,
because
you
won't
get
all
of
them
every
time.
D
E
We
just
define
saying
the
navigation:
one
will
have
these
as
defined
by
the
w3c
spec.
So
when
the
w3c
add
something
else
or
a
browser,
add
something
else
as
long
as
it
conforms
to
the
an
attribute
value.
D
Okay,
so
we
would
just
it:
wouldn't:
have
these
these
subsections,
we
would
just
flat
and
hold
them
up.
E
Yeah,
which,
which
I
think
is
more
like
what
you've
got
an
option:
one
except
an
option
when
you've
listed
type
multiple
times
you
just
dump
them
in
and
say
a
navigation
timing
event
has
all
these
possible
fields
and
then,
depending
on
your
browser,
and
what
happened.
E
D
Okay,
what
about
what
about
the
event
name?
Do
we
want
it
to
be
like
really
generic,
like
this
or
more
specific,
like
navigation.
E
I
was
thinking
we
could
probably
even
go
more
specific
here
and
actually
typically
timing
call
it
resource,
but
this
gets
back
to
the
combination
of
domain
and
name
for
this
particular
stuff.
I
think
this
is
specific
to
browser,
so
this
is
probably
a
unique
one
that
will
be
probably
not
shared
with
mobile
devices.
Although
some
of
this
stuff,
I
could
see
a
mobile
being
able
to
populate
stefan.
It
was
next
week
that
are
you
going
to
get
the
people
coming
over?
Wasn't
it
from
ios
and
android.
A
Exactly
it's
next
week,
tuesday
and
wednesday
more
people
on
wednesday,
since
the
tuesday
meeting
is
quite
late
for
european
time
zone.
Nevertheless,
so
I
wouldn't
count
on
on
timing
events
at
the
moment
on
ios
and
android.
There
is
something
on
android,
but
far
away
from
being
complete
like
this
yeah.
Okay,.
E
Yeah
so
for
now
we're
probably
saying
this
is
specific
to
browser,
so
we
could
probably
say
the
name
would
be
browser
resource
or
browser
timing
or
depending
what
we
want
to
have
as
a
domain.
E
D
Yeah
I
I
was
wondering
about
that
quinn
about
with
relation
to
validation,.
F
Yeah,
I'm
just.
F
The
type
in
the
event
data
will
always
give
you
the
type.
I'm
not
sure
that
exists
in
all
of
the
and
in
all
the
schemas,
like
performance
mark,
doesn't
include
a
type.
E
Yeah
because
it
really
isn't
like
some
of
these
clearly
top-level
fields
like
a
navigation
event,
there
are
other
ones
like
the
the
paint
largest
contentful
paint
measure
mark
to
a
certain
degree,
I'll
probably
make
resources,
probably
timing
related,
and
then
you
can
sort
of
start
discussing
about
perth
ones
as
well.
E
So
I
don't
know
we
can
go
for
a
unique
one
for
everyone,
but
that's
going
to
get
noisy.
I
I
don't
want
to
start
defining
the
world
in
terms
of
events,
I
think,
if
we
can
go
forward,
make
some
of
these
generic.
It
may
be
a
better
way
to
say
it,
so
we
call
out
the
ones
that
everyone
needs,
and
then
we
say
we
have
this
bucket
for
other
ones.
That
would
be
nice
to
have
or
of
more
performance
based
for,
for
some
other
means,
I'm
waffling,
I'm
just
throwing
out
words.
D
Yeah
I
mean,
if
you
wanted
to
if
you
wanted
to
develop,
so
if
you
want
to
do
validation,
if
you
combine
it
into
a
single
like
generic
type
of
event,
and
you
wanted
to
do
validation
of
that,
you
have
the
right
data.
You
would
have
to
know
that
you'd
have
to
look
at
not
just
the
name
but
also
open
up
the
data,
look
for
the
entry
type
and
then
based
on
that
decide
like
which
fields
to
look
for
right.
D
That
is
maybe
a
downside
is
that
there
are
lots
of
lots
of
attributes
listed
for
this
event,
type.
E
Yeah,
which
gets
back
to
my
earlier
question,
is:
do
we
have
an
optional
event.type
as
a
first
level
field,
that'd,
be
domain,
name
type
and
data
so
that
we
could
say
if
the
name
is
timing,
resource
whatever,
then
type
can
identify
that
but
you're
still
going
to
like
crack
the
entire
message
anyway,
if
we
start
applying
validation
so
like
most
of
this
is
going
to
be
transferred
in
json
or
even
if
it's
protobuf,
it's
got
a
got
to
be
a
valid
message.
You've
got
to
crack
it
open
before
you
start
applying
validation
to
it.
D
F
Them
into
individual
events,
yes,
I
just
looked
at
the
schema
and
yeah
the
so
the
entry
type
uniquely
identifies
all
the
all
the
different
data
models.
Yeah.
I
guess
the
question
is
how
how
easy
is
it
to
to
define
all
of
them
using
one
schema
that
yeah
that's
kind
of
the
question
for
me,
you
don't
want
to
have
to
use
imperative
logic.
You
just
want
to
define
the
schema
declaratively
and
then
use
that
for
your
for
your
validation.
E
Well,
can
we
look
at
the
the
w3c
because
they
have
a
bunch
of
grouped
ones
right
because
they
have
the
performance?
Everything
has
a
is
a
performance
entry,
so
if
we
use
the
those
three
like
performance
entry
for
resource
timing
and
navigation
timing
as
as
the
top
level
name,
because
what
a
mark
is
a
performance
entry,
I
think
from
memory.
E
Yeah,
so
if
we
go
for
the
three,
so
performance
mark
looks
like
it
really
is
just
a
performance
entry,
it's
got,
duration,
start
name
and
entry
type,
which
I
think
is
all
in
performance
entry
look
at
that
it
just
has
additional
methods.
What's
the
performance
measurement
look
like.
E
E
D
Yeah
some
of
them
there
are
a
couple
of
these
that
have
nested
objects
in
them.
Like
the
let's
see.
D
E
D
Yeah
we
have
yeah,
we
have
to
figure
out
like
do
we
do.
We
want
to
send
these
send
this
data
and,
if,
yes,
how.
C
G
G
So
I've
been
working
on
the
like
browser
browser
javascript
like
open,
telemetry,
basic
application
just
to
test
some
of
the
some
of
the
traces
that
are
being
seen
from
the
browser
on
that
on
the
automatic
instrumentations.
So
I
saw
that
on
the
documentary
instrumentation,
for
example.
G
So
when
the
document
closed,
there
will
be
a
trace
that
will
be
that
will
be
created
and
the
trace
contains
the
root
spawn,
which
is
the
document
load
spawn
and
that
contains
aventus
the,
and
so
they
even
some
of
the
events
that
you
mentioned
here
on
the
like
on
the
performance
navigation
timing
sum.
Some
of
these
events
will
be.
G
Some
of
these
markers
will
be
reported
on
those
events,
and
there
is
also
another
span
like
document
phase
spam,
where
the
like
the
matrix
or
the
markers
related
to
the
resource,
fetching
will
be
reported
and
there
will
be
if
there
are
other,
like
other
resources
loaded.
There
will
be
other
resource
feature
response
also
attached
to
the
to
the
root
span.
So
that's
how
the
trace
is
reported
when
the
document
looks
so
is
that
is
that
logic
changes
now
or
is
it?
Is
it
going
to
be
one
big
event
that
will
be
reported
now.
E
G
Okay,
so
in
that
case,
like
on
document
cloud
we
can
on,
you
can
only
just
report
all
of
only
those
those
markers
that
are
needed
right.
E
Well,
we'll
define
what
a
document
load
event
looks
like
I.
I
don't
think.
We've
concentrated
that
on
that
here
we're
just
talking
about
the
particular
timing.
Events
at
this
point,
but
as
part
of
the
timing
events,
the
document
load
does
have
the
navigation
event.
So.
E
Yeah,
historically,
because
because
logs
still
doesn't
exist
in
the
the
js
repo,
it's
spans
were
the
only
way
to
get
there
and
spam
events
were
added,
but
the
concentration
of
the
of
open
telemetry
has
been
primarily
for
like
back-end
services,
so
the
instrumentations
that
exist
were
really
occludes
to
to
be
able
to
get
the
data
out,
but
the
actual
events
themselves
haven't
been
defined,
they've
just
been
created
and
used.
In
fact,
I
think
the
documentation
instrumentation
is
still
experimental.
E
I
don't
think
it's
actually
been
delivered
as
production
yet
and.
G
D
Yeah-
and
I
think
I
think
essentially
like
we
want-
we
do
want
to
send-
send
some
like
these
timing
data.
As
events
in
general,
I
think
there's
still
an
option
of
using
spams.
That
would
be
useful
for
tracing
if
you
wanna,
like
tie
a
tie
like
maybe
to
document
load
or
to
a
to
like
a
ajax
cause
that
happened
during
and
then
like
all
the
way
traced
to
like
the
back
ends
that
they
call
yeah.
D
G
So
there
will
be
one
event
like
reporting
all
the
this,
this
markers
right,
that's,
that
is
that
the
plan
need
to
do
it
now.
D
So
so
my
thinking
like
and
I'm
I'm
curious
like
to
hear
everyone's
opinions,
but
navy
mentioned
like
talk
to
talk
talking
about
defining
an
event
for
window
load.
I'm
thinking
do
we
need
it
like,
because
the
navigation
couldn't
be
just
the
navigation
timing,
because
that
has.
C
D
That
is
true,
that
that
was
that
was
one
of
my
questions
actually
down
here.
Do
you
wanna?
If
you
define
these
this,
these
events?
Do
we
want
to
support
only
browsers
that
have
this
this
api,
or
do
we
need
to
do
we
define
these
semantic
conventions
and
say
like
if
the
api
doesn't
exist,
you
can.
You
can
fill
in
any
of
these
attributes
that
you
can.
E
Yeah,
I
think
it's
it
we're
gonna
gonna,
be
in
a
situation
where,
like
pretty
much
all
of
these
attributes
that
we've
got
listed
on
screen
now
it
are
going
to
be
optional
because,
like
the
main
lookup
start
and
end,
even
if
it
does
exist,
if
the
browser
supplies
that
you
won't
get
that
with
every
request,
because
it's
already
done
the
dns
lookup,
you
don't
get
that
on
the
ones,
that's
right
yeah.
So
I
think
it's
going
to
be
a
case.
E
D
Yeah
I
mean,
and
like
related
related
to
that
you
could
have
you
could
have
window,
you
could
have
navigations
where
or
like
page
loads,
where
the
load
event
is
is
very
it's
very
long.
You
know.
Maybe
it
takes
like
20
seconds
and
the
user
navigates
away
before
the
window
load
event,
fires,
and
then
you
can
have
a
navigation
event
without
the
window
load
value
right.
So
so,
in
that
case,
like
you,
wouldn't
even
have
window
load
event.
E
E
G
D
Okay,
so
so
back
going
back
to
the
the
event
name
being
broad
or
more
specific.
E
F
E
So
that
the
combination
of
the
domain
and
the
name
identifies
the
thing
that
you're
playing
with,
but
so
like
you
go
option
two
and
just
say
event:
name
is
paint,
someone
might
want
to
paint,
might
come
up
with
a
paint
event
later
or
if
navigations
might
be
a
better
one.
We
might
want
to
say
the
page
load
event
is
also
considered
a
navigation.
E
So
therefore
you
might
want
to
say
well.
The
domain
is
timing.
Your
browser
timing
versus
the
general
page
load
event.
E
E
D
D
D
There's
I
just
want
to
clarify
spans
versus
events.
The
current
experimental
code
for
for
browser
captures
resources
as
spans
and
based
on
this
proposal
here
we're
proposing
we're
gonna
capture
them
as
events.
I
just
wanted
to
confirm
that
we're
going
to
draw
up
the
spans
or
we're
thinking
of
dropping
the
spans
they're,
not
not
useful.
E
Yeah,
so
the
event
that's
santosh
is
not
here:
santosh
api.
The
event
may
have
a
span
linked
to
it,
so
that
you
can
go
backwards,
but
it
won't
be
expand
on
its
own
yeah.
D
Okay,
I
think
I
think
the
only
way
that,
like
a
resource
like
I
don't
know
like
an
image
or
css,
could
be
a
spam
useful
as
a
spam
like
if
it
was
linked
to
like
a
maybe
like
the
back
end
that
generated
it.
But
I
don't
think.
E
Well,
they're
not
clear
spans,
it's
a
case
of
if,
for
example,
if
you
look
if
you're
loading
up
a
div
and
as
part
of
that
div
you're
doing
some
form
of
spa
navigation,
it
makes
logical
sense
that
you
create
a
credit
span.
You
go
and
do
that
and
then,
when
you're
finished,
everything
is
associated
with
that
spam,
not
that
the
resources
and
events
that
happen
as
part
of
lighting
that
span
are
their
own
spans.
H
E
E
So
we
have
a
have
this
the
span
from
the
from
the
user,
the
page
loads
we
have,
although
all
the
navigation
resource
timings
here
you
we
may
want
to
go
and
pull
out
all
the
resource,
timings
for
the
images
or
the
css
or
whatever
else
happened.
F
C
F
Come
back
to,
where
is
the
data
going
so,
for
example,
with
with
aws
we
have
we
have
tracing
and
then
we
have
kind
of
an
event
store,
and
so,
when
it
comes
to
the
question
of
where
do
we
want
to
put
this?
It's
it's
ultimately
both
it
depends.
It
depends
on
the
use
case.
So
if
we
think
of
this
as
an
event,
then
you
know
people
go.
They
query
the
events
they.
You
know
it's
a
single,
it's
a
single
data
point
that
contains
timing
data.
F
If,
if
we
think
of
it
as
a
span,
then
yeah
you
can
go
and
you
can
look
at
all
the
sub
elements,
like
all
the
all
the
resources,
all
the
all
the
xhr
requests,
so
it's
at
least
for
us.
This
serves
the
dual
purpose
and
it's
it's
really
going
to
both
of
those
both
of
those
stores.
So
we
think
about
it
in
both
of
those
ways.
H
F
E
Now
part
of
the
problem
is,
you
will
get
some
resources,
sometimes
some
events
which
are
effectively
have
a
duration
of
zero
and
the
factory
spans
of
zero
length.
I
I
don't
know
if
they
end
up
being
specked
out
as
the
fact
these
fans
aren't
supposed
to
have
a
zero
length.
It
just
end
up
being
a
hat,
because
there
was
only
traces
and
the
other
current
issue
which
I'm
going
to
be
raising
a
speculation.
Pr
for
is
span.
E
Events
can't
have
nested
data
right
now,
they're
specked
out
so
they're
it's
supposed
to
be
flat,
and
I
know
from
our
perspective,
we
need
the
ability
for
users
to
be
able
to
find
effectively
a
hierarchy
of
attributes
that
they
define
themselves
that
we're
not
defining
as
part
of
the
semantic
conventions.
It's
just
going
to
be
a
field
that
they
can
go
and
populate
with
their
own
event.
Data.
E
G
E
If
they're
not
fetched
locally
from
a
local
cache,
which
in
case
they
would
have
a
zero
duration,
but
but
other
events
will
have
that
there's
nothing.
We
can
do
for
it
like.
How
long
does
it
take
the
user
to
click
a
button?
E
G
D
Sure
yeah,
so
I
mean
we
can
the
browser
browser
sdk
can
still
do
tracing.
I
think
what
we're
what
we've
and-
and
I
think
on
the
flip
side
also,
I
think
events,
events
just
because
can
carry
like
different
types
of
data
they
can.
D
They
can
carry
information
about
about
durations
as
well,
but
I
think
I
mean
this
is
a
good
discussion
right
I
mean,
and
we
had
this
discussion
in
the
past
and
I
think,
there's
about
using
events
versus
spans
and
we
kind
of
landed
on
that
it
made
sense
to
to
send
most
data
as
events,
just
because
it's
it's
lighter
and
it
doesn't
rely
on
tracing
and
also
also
there
are
some
sometimes
when
it
just
does
not
make
sense
to
create
a
span
for
for
things
like
like
in
this
case,
like
when
I
asked
about
the
resources
like,
I
was
asking
specifically
because
resources
these
these
types
of
data.
D
G
Yeah
and
on
document
load,
I
think
the
trace
created
has
through
spawn
the
document
load
span
and
then
sure
yeah
you're
done
will
be
document
page
and
resource
response.
D
E
C
E
H
E
E
We
will
be
defining
as
part
of
this
group
what
a
document
load
event
looks
like.
Yes,.
D
Okay,
so
yes,
let's,
let's,
let's
continue
this.
This
is
the
discussion
next
week
and
I
think
maybe
it
sounds
like
we
have
to
just
talk
a
lot
a
little
bit
more
about
the
spans
option.
D
E
E
If
you
follow
ted's
rationale,
the
ad
span
will
actually
just
create
an
event
anyway.
Now
linking
the
whatever
the
current
spain
is
to
it.