►
From YouTube: 2023-02-22 meeting
Description
cncf-opentelemetry meeting-2's Personal Meeting Room
A
A
Okay,
I
think
we
can
start
so
I
I
added
I
created
this
issue
Jack,
based
on
what
you
wrote,
the
readme
for
everyone
else.
The
readme
for
the
logs
includes
phrases
about
the
the
event
right
now,
so
I
think
what
we
can
do
would
be
desirable
to
also
declare
the
readme
stable
right
for
that
document.
So
I
think
what
we
could
do
is
for
now
remove
the
bits
that
we're
unsure
about,
particularly
where
it
refers
to
the
to
the
specifics
of
the
events
from
the
readme
move.
A
It
elsewhere,
maybe
not
delete
move
it
elsewhere,
so
that
we
can
just
Mark
the
release
table
and
then
additive
changes
I
believe
are
fine
to
stable
documents
if
they
don't
contradict
with
all.
What
already
is
there.
So
when
we
are
certain
about
how
the
events
will
work,
we
can
add
them
back.
So
that
was
what
I
was
thinking
about.
I,
don't
know
if
you
guys
have
any
thoughts.
B
That
sounds
reasonable.
A
couple
places
come
to
mind.
He
could
move
it
as
a
a
section
within
the
event,
API
document
or
in
the
event
semantic
convention
document.
Although
the
semantic
convention
document
is
a
bit
more
buried,
probably
harder
to
come
across
and
then
another
strategy
that
some
of
these
documents
take
is
they
have
mixed
stability,
where
one
specific
section
is
experimental
and
the
rest
is
stable.
A
What
could
that
is
just
so
sprinkled
here
and
there
in
the
readme?
It
would
be
very
like
without
a
perception-
and
here
is
just
a
center
sentence
here-
a
sentence.
There
I
think
it's
it's
much
harder
to
do
that
like
that,
so
maybe
just
if
we
just
make
it
a
separate
section
like
everything
about
the
events,
a
separate
section
that
would
could
work
as
well.
Both
were
editing
like
maybe
just
move
it
to
the
events.
Api,
like
you,
said
right.
C
A
I
just
wanted
to
clarify
that
stable
doesn't
mean
that
nothing
can
change
ever
in
a
file
right,
especially
in
a
file
like
readme,
which
is
typically
non-normative
right.
It's
it
may
contain
the
elements
of
the
specification,
but
typically
is
sort
of
a
more
of
a
prose
that
helps
to
understand
things
so
I.
What
I
was
trying
to
say
that
there's
no
reason
that
in
the
future,
the
readme
cannot
contain
description
of
how
events
work.
A
So
if
we
want
to
add
that
in
the
future,
I
think
it's
completely
acceptable
to
do
so,
even
though
the
document
itself
is
marked,
stable,
stable
just
means
that
the
portions
that
you
can
consider
to
be
a
specification
like
you
have
like
normative
language
from
RFC
like
capitalized,
shoot
and
master
Noble
stocks,
those
you
cannot
change
or
remove
right
from
the
document.
That's
that's
the
the
meaning
and
a
similar
thing
is
happening
with
the
schema
files
right
now,
so
there
I
think
we
decided
to
do
the
same
thing
that
that's.
Why
right
I
thought?
A
Let's
do
the
same
thing
here.
The
alternate
would
be
to
like
not
Mark
the
readme
at
all,
with
any
stability
markers,
but
that
would
require
to
extract
all
the
language
from
there
all
the
all,
the
all
the
I
guess,
part
parts
that
are
actually
a
specification
are
supposed
to
be
part
of
the
specification
to
a
separate
place
and
I.
Don't
know
how
that
I
mean
it's
possible,
but
I
I
can
imagine
it's
a
lot
more
work
because
we're
going
to
kind
of
you,
you
will
need
to
kind
of
rewrite
all
those
things.
A
A
Okay,
so
if
we're
good
with
that,
then
let's,
let's
move
to
the
next
one.
D
This
is
really
just
a
carryover
from
last
week,
where
Jack
added
some
comments,
so
I
think
I've
now
added
some
additional
wording
for
that
it
ended
up
being
a
lot
of
words,
a
lot
more
words
than
I
thought,
but
that's
it's
there
ready
for
review.
One
thing
I
did
add,
is
the
second
link
I've
got.
There
is
a
a
section
about
your
possibly
open
or
experimental
issues
and
extensions
I've
not
seen
this
in
any
other
doc.
C
Could
could
you
do
a
short
summary
nav
of
the
change.
D
It
really
is
just
iterating,
probably
more
forcefully
than
it
had
previously.
That
event.data
is
only
contains
the
data
based
on
the
a
domain
name
combination
or
what
I'm
calling
the
domain
specific
schema.
D
The
other
fields
can
be
used
for
providing
more
context
for
custom
events.
They
should
go
and
Define
their
own
schema,
so
it
really
is
a
case
of
yeah.
While
we
support
other
attributes,
because
we
can't
block
people
from
adding
attributes
either
in
a
downstream
process
or
elsewhere.
B
You
may
sorry
I
missed
the
part.
You
said
about
custom
events
and
having
their
own
schema.
Would
you
imagine
that
the
the
payload
for
in
attributes
for
custom
events
go
and
event
dot
data
or
in
yes
other
top
level?
Okay,.
D
C
So
I
I
think
event.data
is
still
an
optional
attribute
events.
Do
it's
not
a
mandatory
at
about
events
can
still
only
have
name
and
domain
and
anything
else.
There's
there's
still
events
so
just
like
many
other
semantic
conventions.
This
is
just
one
recommendation
for
people
to
put
their
payload
into,
but
it's
not
the
only
place.
D
Yeah
in
the
change
as
well
saying,
the
reason
eventider
is
optional
primarily,
is
to
support
pink
type
events
where
you're
just
saying
hey,
I'm
alive,
and
there
is
no
payload
but
I
use.
The
word
should
for
custom
events
using
event
data.
C
So
Jack,
you
asked
a
question:
when
should
what
is
the
guidance
on
when
to
put
attributes
into
event
or
data
versus
the
top
level
attributes
there
is?
There
is
no,
you
know
strict
guidance.
You
know
we
have
on
on
that.
So
far,
I
think
it's
it's
just
that.
D
No
I
I
put
that
in
the
document.
The
strict
guidance
is,
they
should
use
event.data
I'm,
not
saying
they
they
can't,
but
the
guidance
is
they
should,
but
that's
what
the
the
change
last
night
was
about.
B
I
gotta
think
about
it.
Foreign.
B
I
think
like
so
what
I
want
to
do
is
I
want
to
I,
want
to
take
some
time,
and
you
know
think
about
the
implications
of
this.
B
This
is
really
the
first
time
that
we
would
be
using
complex
attributes
as
like
a
first
class
citizen
in
the
semantic
conventions,
and
so
it's
really
a
forcing
function
to
get
otlp
receivers
to
accept
complex
attributes
and
then
the
other
thing
that
I
think
is
I
I
want
to
discuss
is,
is
you
know,
I
want
to
discuss
this
with
the
javasig,
because
those
folks
have
some
of
them
have
strong
opinions
about
this
event
stuff,
even
though
they're
not
attending
this
sig,
so
I'm
going
to
run
it
past
them
as
well.
B
C
One
one
other
thing
that
will
be
really
helpful
is
I.
Think
so
far
we're
only
talking
about
the
ram
events.
It
will
be
really
helpful
if
there
are
more
use
cases
from
from
other
domains.
C
C
What
do
they
mean
and
and
I
think
yesterday,
in
other
context,
never
mentioned
that
this,
the
dot
net
in
a
Windows
events,
you
know
they
they
might
generate
events
that
that
show
up
in
the
Windows
Event
Viewer
I
think
there
was
a
code
piece
of
code
shared
by
Riley
on
on
how
the
logging
Library
can
be
used
to
generate
events.
In.Net
I
think
they
they
they
are
no
different
from
logs.
C
A
So
Windows
events
they
are,
they
are
really
Logs
with
a
fancy
way
of
viewing
them.
Instead
of
putting
them
in
a
file
in
a
human,
readable
format,
Windows
puts
them
in
some
some
binary
format
and
you
have
what
is
called
an
Event
Viewer
to
see
them,
but
they
are
really
structured
books.
A
Correct
actually
right
applications
can
log
stuff
systems
logs
stuff,
I
I,
don't
know
like
if
you
can
call
that
those
events,
the
same
kind
of
events
that
you're
envisioning
here
in
use
by
by
Rama
or
some
other
client,
instrumentation
library
or
whatever.
C
Yeah,
that
is
correct,
I
think
in
the
case
of
ram
we
are,
we
are
really
receiving
those
events
and
on
the
back
ends
we
are
going
to
create
metrics
out
of
them
the
the
raw
events
themselves.
C
You
know
don't
have
a
lot
of
significance
because
they
are
from
just
one
user,
whereas
I
believe
both
the
the
logs
and
and
these
windows
events.
Now
people
will
be
looking
at
them.
A
Yeah
and
by
the
way
for
Windows
events,
we
we
already
have
receiver
in
the
collector
The
Collector,
collects
those
events
and
turns
them
into
log
records,
as
you
would
expect
just
like
it
collects
stuff
from
files
right.
So
we
treat
them
the
same
way
in
The
Collector,
essentially
yeah
as
logs
structured
logs,
fine,
but
they
are
just
log
records
there
in
the
collector,
like
what
I'm
saying
is
that
I?
A
Don't
think
there
will
be
an
expectation
that
the
events,
the
windows
events,
the
payload
of
the
windows
events-
will
be
putting
to
event
top
data
because
they
are
called
events
and
because
we
have
a
notion
of
event.data.
C
Is
there
any
relevance
of
schema
for
for
any
of
these
events.
C
Like
for,
for
our
events,
the
reason
we
for
rum
events,
the
reason
we
are
talking
about
having
a
schema
is
these
events.
Are
they
come
from
an
unauthenticated?
Source
authentication
is
a
hard
topic
for
rum
sources,
and
so
we
want
to
validate.
The
data
we
receive
is
conforming
to
what
we
expect.
So
we
are
thinking
of
attaching
a
schema,
but
is
it
is?
It
is
a
schema
relevant
for
other
domains
too.
C
C
Yeah
we're
just
saying
that
for
this
domain
name
combo,
these
are
the
expected.
This
is
the
expected
payload.
C
This
point:
it
is
only
an
intention
we
want
to
go
in
that
direction.
There's
no
Clarity
yet
on
how
to
actually
implement.
D
It
yeah
that's
one
of
the
open
issues
that
I
put
at
the
bottom.
At
the
moment,
it
is
a
convention
that
will
be
documented
and
I
described
it
as
known
events.
So
no
one
open
to
laboratory
events,
you
know
back
ends
could
apply
any
validation
based
on
what
we've
documented
or
what
a
third
party
is
documented
for
their
own
custom
events,
but
yeah
at
some
point,
we'll
want
to
version
that
which
then
leads
us
down
the
schema
path.
A
A
However,
we
in
the
past,
when
we
discussed
the
schema
files,
this
was
a
topic
right,
whether
it
needs
to
be
just
Deltas,
or
maybe
we
want
to
capture
the
entire
State
as
well.
Precisely
for
one
of
the
one
of
the
reasons
was
the
validation.
How
do
you
validate
the
event
whether
it
confirms
with
a
schema
or
no,
if
you
need
to
plus
maybe
record
some
other
metadata
about
it
like
what
how
to
render
the
particular
attribute?
What's
what's
the
meaning
of
it
whatever
right?
So,
you
may
include
additional
data
yeah.
D
Yep,
that's
my
first
bullet
point:
I
had
there
is
to
find
a
higher
level
of
telemetry
logs.
The
only
complication
this
one
has
is
it's
going
to
be
defined
based
on
you
know,
other
values
within
the
log
record
itself
like
the
event
name
and
domain,
so
yeah,
but
yeah.
D
A
D
C
Yeah
I
think
it's
it's
just
a
list
of
fields
corresponding
to
each
name,
domain
combination
and
their
data
type.
A
Since
we're
discussing
this-
just
maybe
it's
wordful
so
telling
you
about
this,
so
we
just
had
a
PC
meeting
like
an
hour
ago
and
we're
talking
about
what
projects
we're
working
on
and
how
do
we
make
sure
that
we
have
appropriate
sponsorship
from
the
TC
members
for
each
of
the
projects
and
your
needs
I
think
they
are
very
valid
but
the,
but
they
they
require
significant
investment
of
of
of
time
of
open
Telemetry
right,
whether
it's
just
a
TC
member
or
or
the
actual
contributor
to
work
on
this
I'm
a
bit
worried
that.
A
So
we
need
to
find
a
way
to
make
sure
that
we
are.
We
are
allocating
enough
time
like
if,
if,
if
I'm,
that
sponsor
I,
don't
honestly
I
don't
feel
comfortable
with
my
level
of
knowledge
and
understanding
of
the
problems
to
be
efficient
as
a
sponsor,
so
I
would
need
to
invest
a
lot
more
right
personally
to
to
learn
more
before
I
can
be
efficient
in
that
job.
So
that's
that's
my
worry
a
bit
at
this
moment.
It
may
well
be
that
before
I
can
actively
sponsor
it.
Maybe
we'll
need
to
wait
a
bit.
A
A
Just
just
just
be
aware,
right
we're
trying
to
solve
this,
maybe
that
we,
and
especially
the
other
part
of
it,
like
the
ephemeral
resource
attributes,
I,
think
that
depends
on
the
the
the
other
initiative
that
we
wanted
to
have
with
ability
to
have
mutable
attributes
of
the
resource.
But
we
talked
about
it
last
week
right
that
itself
is
a
complicated
thing,
so
I'm
kind
of
this
this.
A
This
is
a
bit
worrying
to
me
that
we're
kind
of
the
more
the
more
we
talk
about
it,
the
more
complicated
stuff,
I
discover,
Ed
and,
as
a
result,
I'm
kind
of
a
bit
worried
that
this
can
get
delayed.
Even
more
I,
don't
know
if
there
is
a
way
to
maybe
cut
a
smaller
slice
of
the
problem
that
you're
trying
to
solve,
and
maybe
Solve
IT,
initially
without
being
blocked
and
then
leave.
Maybe
those
other
problems
for
the
later
something
to
think
about.
A
C
Actually,
actually,
at
this
time
only
this
event,
dot
data
aspect
is
the
you
know,
critical
pending
item
for
rum
with
I
think,
even
though
the
events
API
SDK,
you
know
we
have
talked,
we
have
gone
back
and
forth
on
whether
it's
really
needed
yeah.
A
Data,
but
do
you
think
it's
it's
it's
like
sufficient
to
just
say
that
this
is
the
semantic
convention
for
event.data
and
stop
there
or
you
think
we
have
to
also
solve
the
problem
of
the
the
describing
the
schema,
the
shape
of
the
payload
and
all
that
stuff
and
which,
in
turn
means
that
we
have
to
figure
out
how
to
record.
C
C
But
we
can,
this
can
be
an
evolution.
You
know
we
don't
have
to
solve
everything
at
once.
At
this
point,
I
think
we
can
make
significant
progress.
C
You
know
with
with
just
this
event
or
data,
you
know,
being
the
last
one,
the
ephemeral
resources
can
come
later.
The
schema
can
come.
Even
you
know,
after
that,
okay.
A
That's
good,
if
that's
that's
the
case,
that's
good,
just
to
be
sure
that
it's
possible
to
up
those
those
new
things
later.
You
know
it
won't
break
what
what
you
already
have
right.
F
C
Yeah
yeah
I
I
feel
more
importantly,
we
don't
want
to
go
back
on
the
events
specification
as
much
as
possible,
given
that
we,
you
know,
JavaScript
things
move
slower,
we
are
making,
you
know,
slow
progress
in
on
the
implementation
side,
and
if
we
have
to
redo
things,
you
know
it
will
be
more
expensive.
So,
whatever
changes
to
the
spec,
we
can
make
as
much
as
possible.
I
know
you
know
we
cannot
guarantee
anything.
C
You
know
if
we
can
pull
in
understanding
of
events
in
other
domains.
You
know
that
will
be
great
like,
for
example,
I
know
kubernetes.
You
know
we,
we
kubernetes
events,
we
create
log
records
for
them,
but
they
are
not
conforming
to
the
the
event
specification.
C
A
C
Business
events,
I
I,
believe,
are
events
created
by
the
application
authors
when,
when,
when
people
add
the
instrumentation
libraries
to
their
application
and
and
then
put
together
with
the
SDK,
you
know
they
might
want
to
create
additional
events.
Themselves
is
what
I
feel
refers
to
the
business
events.
Let's
say
you
know
you,
you
know
you
tell
the
customers,
hey,
you
integrate
our
agents,
but
Additionally.
You
know
you
can
you
can
create
these
events.
A
A
A
C
Not
really,
it
is
telemetry
like
like
they.
They
can.
A
C
Me
yeah
I'm
thinking
a
lot,
but
let
me
give
an
example:
let's
say
an
e-commerce
backend
application
wants
to
emit
an
event
for
every
product
that
people
visited
versus
purchased.
You
know
they
might
want
to
identify
the
let's
say
the
conversion
in
terms
of
the
value
so
for
each
product.
You
know
they
want
to
emit
an
event
saying
this
is
the
value
of
the
product
people
have
seen,
and
this
is
the
value
of
the
product
that
they
have.
C
You
know
purchased,
and
you
want
to
do
that
analysis
in
the
back
end.
So
you
all
you
want
to
do
in
the
in
on
the
in
the
application.
Is
you
want
to
emit
events.
A
Yeah,
so
in
in
any
e-commerce
system,
this
is
going
to
be
designed
from
I
guess
from
from
ground
to
beat
an
essential
part
of
that
system.
Right,
it's
I,
I
personally,
don't
see
how
you
call
that
Telemetry.
To
be
honest,.
B
A
Database,
like
yeah
you're,
going
to
have
reports
that
run
on
this
thing
right,
telemetries,
something
that
you
can
enable
disable
sample.
Maybe
like
have
some
retention
period,
you
used
to
scrap
it
after
some
time,
that's
very
different
than
than
something
my
business
depends
on
what
products
people
click
on,
what
what
they
purchase
like
what
revenue
from
this
thing,
some
statistics
on
that.
That's
that's
a
very,
very
that's.
A
very
specialized
barrier
right,
like
I,
don't
see
how
you
could
rely
on
open
climacy
to
deliver
those
events
for
you
to
collect
capture.
A
A
C
Well,
that's
that's
an
Ops
problem
right,
like
I
I,
think
that's
a
separate
problem.
I
think
that
it's
important
to
realize
that's
a
possibility
and,
and
then
the
customers
will
have
to
manage
that,
but
but
I
think
open
Telemetry
can
enable
you
know
solving
these
problems.
I
am
still
not
clear
why
it's
not
relevant.
C
Let
me
give
you
a
link.
D
Probably
some
better
real
world
real
world
style
would
be
in
the
case
of
Microsoft
teams.
They
use
our
internal
SDK,
which
at
some
point
would
eventually
be
replaced
with
open
Telemetry.
If
I
can
get
to
work
on
a
web
to
do
things
like
you
know,
measure
their
the
amount
of
time
someone's
on
a
phone
call
which
applications
they've
they've
loaded.
These
are
all
custom
level
events
that
they
report
to
their
back
end.
D
Some
of
them
are
throttled,
so
some
of
them
are,
you
know,
limited
to
a
certain
subset
of
people,
but
others
they
want
100
of
them
so,
but
they
would
be
application.
Level,
Customer,
Events
or
in
this
case
framework
double
Customer
Events
office
also
have
our
own
set
of
events.
They
do
the
same
thing
for.
C
Yeah
I
I
have
some
documentation
from
neuralik,
but
this
is
still
talking
about
the
ramside
events.
I
am
not
sure
if
this
is
applicable
to
the
back
end.
Applications
too,
but
I,
remember,
I.
I
cannot
find
the
link
but
I
remember
seeing
that
use
case.
B
It
is
used
in
back-end
applications.
Unfortunately,
I
don't
have
a
I.
Don't
have
a
lot
of
great
examples
off
the
top
of
my
head,
but
I
know
that
our
internal
teams
use
custom
events
all
over
the
place
too
track
their
applications.
C
F
I
think
I.
Can
you
know?
I
can
definitely
say
that
it's
that's
the
case
like
I
worked
on
on
this.
The
project
here
I
think
these
events
specifically
are
like
some
of
these
are
called
events
but
they're
like
the
defined
events
with
schema,
but
but
there's
like
the
customers
like
use
the
custom
events
API,
all
the
time
like
in
in
browser
and
mobile
applications,.
B
I
I
added
a
couple
of
examples
to
the
to
the
document,
so
one
is
the
Java
runtime
time
has
this
tool
called
JFR
Java
flight
recorder.
B
Java
flight
recorder
allows
you
to
consume
a
stream
of
events
that
you
know
are
of
interest
to
that
and
which
have
occurred
in
the
runtime,
and
you
know
the
events
track
all
sorts
of
things,
some
of
them
you
might
want
to
aggregate
into
metrics,
but
others
you
might
want
to
translate
into
you
know
you
might
want
to
capture
as
is
and
and
send
up
to
some
Telemetry
back
end.
B
I'll
include
a
link
in
this
document,
for
you
know
an
index
of
the
types
of
events
that
are
available
from
JFR,
so
you
can
get
an
idea.
A
couple.
Others
would
be.
You
know,
database
migration
events,
so
if
an
application
migrates
its
database
schema,
that's
an
intro,
that's
a
an
interesting
thing
that
can
to
observe
and
can
cause
problems
with.
You
know
the
application
and
then
applications
start
and
shut
down,
and
you
can
imagine
when
an
application
starts.
It
could
emit
an
event
with
you
know.
It's
the.
D
B
It's
version,
and
you
can
monitor
the
events
to
you,
know,
get
a
feel
for
when
new
deployments
took
place
and
track
all
the
different
metadata
associated
with
those
deployments
over
time.
C
So
yeah,
so
there
are
valid
use
cases
right.
So
how
do
we
combine
the
requirements
for
these
type
of
use
cases
with
with
how
we
are
defining
the
specification
for
events.
A
A
B
Yeah,
that's
a
good
point.
You
know.
If
we
have
a
specific
event
you
can.
You
can
look
for
application
start
and
shutdowns
across
across
all
of
your
different
applications,
because
they'll
all
have
a
particular
fingerprint.
So
you
can,
you
know,
search
for
a
specific
thing,
so
that's
helpful
versus
you
know
if
every
application
has
their
own
sort
of
pattern,
that
you
have
to
look
for
to
represents
it.
It's
it's
startup,
but
I,
see
what
you're
saying
I.
A
A
B
But
a
log
record
with
a
you
know:
a
well-defined
schema,
that's
kind
of
what
we're
talking
about
with
events
so.
C
Yeah
I
think
I
think
we
maybe
it
it's
it's
better
to
not
talk
too
much
about
you
know,
which
is
the
right
one.
Maybe
we
just
Define
some
conventions
and
leave
it
to
people
to
use
whichever
works
for
them.
E
E
Okay,
yes
I
just
wanted
to
kind
of
build
on
what
you
said:
T
Grim.
We
have
this
case
in.net.
Currently,
you
know
there's
some
event.
Things
like
we
talked
about
Windows
earlier
we
have
the
Event
Source.
We
have
other
events.
Libraries,
like
Nev,
said
we
have
some
internal
sdks
in
Microsoft,
so
I'm
working
with
a
team
that
runs
like
the
Whiteboard
app
that
comes
with
Windows.
They
use
like
a
DOT
net
event.
Sdk
I
gave
them
or
I'm
working
on
an
open,
Telemetry
integration
to
that
Library.
E
So
the
app
writes
these
events
using
its
own
API
and
I,
just
shim
them
up
as
log
records
and
essentially
do
log
record
appending
and
it
has
worked.
Fine
I've
had
no
need
for
anything
else.
Nobody's
asked
for,
like
schema
or
validation
and
I
think
it
would
be
like
impossible
to
even
do
that,
because
these
apps
have
like
many
many
tens
of
hundreds,
maybe
more
events
and
there's
really
no
need
for
the
SDK
to
validate
it.
You
know
they
own
that
our
backends
that
receive
this
data
seem
to
be
pretty
resilient.
E
So
for
me
and
my.net
universe,
I,
don't
really
have
a
need
yet
or
anything
really
Beyond,
the
log
appender
or
whatever
we
call
it.
You
know
the
exception.
Semantic
conventions
was
nice
on
events
I,
maybe
event
ID
would
be
useful.
For
me,
a
lot
of
teams
are
really
interested
and
strongly
typing
those
things,
but
we're
pretty
happy
with
the
shape
of
things.
So
that's
just
a
data
point
for
you
guys
to
consider.
B
And
Mike,
let
me
let
me
kind
of
I
guess
expand
on
that
as
well,
so
these
use
cases
I
brought
up
I,
don't
hear
anybody
clamoring
for
them.
Even
the
JFR
situation,
we've
been
able
to
make
do
with
aggregating,
consuming
most
JFR
events
and
aggregating
them
into
into
various
metrics
and
they're.
There
haven't
really
been.
F
B
Is
there
one?
One
situation
comes
to
mind
where
events
would
be
useful
and
so
there's
this
proposal
that
was
made
in
the
Java
space
from
Splunk
to
donate
their
Android
observability
product
and
in
that
product
they
they
observe
various
things
that
are
very
event-like,
but
they
use
zero
duration
spans
in
order
to
send
those
up.
B
So
in
those
cases
it
it
might
be,
those
might
be
better
suited
as
events
then
zero
duration,
spans,
but
again
Android
is
kind
of
on
the
ground,
client-side
side
of
things.
So
that
seems
to
be
really
where
a
lot
of
the
concrete
use
cases
are
emerging.
D
But
I
I
just
dropped
a
comment
in
the
chat
which
is
from
the
pr
itself,
and
this
is
you
know
primarily
driven
about.
We
have
effectively
certain
uis
that
represent
our
real
user
metrics,
which
is
based
on
the
known
event,
so
yeah,
based
on
the
page
view,
the
fetch
calls.
You
know
the
Ajax
requests
that
they
make
etc,
etc.
So
you
know
that.