►
From YouTube: 2021-10-06 meeting
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
B
B
Oh,
I
was
in,
I
went
to
strange
loop
strange
loop
conference
last
week,
oh
cool
yeah,
steve,
and
I
gave
a
workshop
on
open,
telemetry
there.
So
nice.
B
Strange
loop
is
a
crazy
generalist
conference
that
has
academics,
artists,
engineers,
it's
it's
amazing,
like
it's
one
of
the
coolest
cross-functional
conferences
ever
like
the
best
talk.
The
best
talk
was
a
woman
who's,
a
particle
physicist
at
cern,
who
also
is
a
modern
dance
choreographer
and
she
trained.
She
basically
put
on
a
motion:
capture
suit
and
trained
neural
networks,
the
same
kinds
of
neural
networks.
B
She
used
for
particle
physics,
analysis
on
her
dance
moves
and
used
it
to
inform
new
moves
and
like
understand
better
how
her
like
the
connections
between
her
body
parts
when
she's
dancing
and
yeah.
It's
really
it's
like
amazing
stuff,
like
that,
like
just
crazy,
crazy
things,
you
won't
get
at
cubecon
or
aws
reinvent.
F
E
We're
expecting
at
least
one
of
them
to
join.
I
talked
to
daniel
about
that
earlier
this
week.
I
don't
think
he
was
going
to
join.
He
mentioned
someone
else
from
the
js
cigwood.
E
Okay,
so
I
mean,
I
think
almost
all
of
us
were
here
last
week
I
had
mentioned
last
week
that
I
probably
wouldn't
be
returning
to
a
lot
of
these
and
a
few
people
messaged
me
after
and
said:
can
you
please
return
for
the
next
few
weeks,
at
least
so
I'll
be
sticking
around
as
a
resource
for
the
for
the
next?
While
that
being
said,
I
think
the
first
item
on
the
agenda
is
the
plan
doc.
E
D
Yeah
yeah,
so
I
basically
took
your
the
example
doc
that
you
shared
with
for
the
vlogging
and
looked
through
that,
and
so
I
basically
did
the
same
thing.
I
copied
the
the
main
thing
that
they
that
wasn't
that
dark-
and
I
I
don't
know
like
if
you
want
to
you
know
I
mean
it-
sounds
like
the
log
logging
like
that
project
was
maybe
even
bigger
in
scope
than
what
we
have
for.
D
I
know
that,
like
that
was
divided
like
into
multiple
work
streams
that
did
like
investigation
on
existing
products
and
stuff
like
that.
So
I
don't
know
if
you
need
to
do
that
like
that,
but
you
know
still.
I
think
it's
a
good
idea
to
maybe
have
a
shared
document
where
we
can
describe
the
vision,
the
goals
and
can
I
discuss
what's
what's
missing?
D
What
are
the
gaps
we're
trying
to
fill
so
I
didn't
so
yeah
I
actually
just
put
in
the
structure
and
other
people
have
been
adding
things
in.
So
that's
great,
I
guess,
like
my
first
question
like
do
we
wanna
go
through
this
and
fill
out
this
document
like
in
these
meetings,
or
is
that
something
that
you
wanna
do
async
and
discuss
async.
E
A
Yeah
yeah,
I
was
the
one
that
added
most
of
the
content
there
and
actually
I
was
thinking
the
original
proposal
from
alolita
that
started
this
whole
conversation.
I
think
I
don't
see
anybody
from
aws
in
this
calls.
Maybe
we
should
invite
them
include
them.
I.
E
Talked
to
elita
last
week
she
said
they
will
have
someone
joining.
She
does
a
lot
of
leadership
for
the
collector
sig,
which
unfortunately
meets
at
the
exact
same
time.
Okay.
Hence
why
she's
not
here?
She
also
was
one
of
the
people.
Who'd
said
hey.
If
I'm
going
to
walk
on
the
collective
morgan,
can
you
give
guidance
to
the
rum
sig,
but
she
did
mention
that
one
of
her
engineers
would
be
joining
in
the
coming
coming
weeks.
I
think
they
have
several
people
on
vacation
right
now,
but
but
she
knows.
D
Okay,
great
morgan
is
there:
is
there
any
any
update
on
the.
E
I
reached
out
to
the
cncf,
so
we're
gonna
need
to
do
one
of
two
things.
The
cncf
had
thought
that
kubernetes
had
fixed
this
somehow
and
it
turns
out.
Kubernetes
just
has
like
15
zoom.
A
Accounts
and.
E
Has
the
exact
same
problem
as
us,
just
even
at
even
higher
scale,
so
we're
either
going
to
get
an
extra
zoom
account
or
I'm
going
to
figure
out
on
friday?
I
have
some
time
that
I
have
blocked
off
how
to
somehow
rig
up
zoom
to
have
unique
ids
for
every
meeting
of
a
single
zoom
account,
which
I
think
I
know
how
to
set
up.
If
so,
I
will
solve
the
problem
for
kubernetes
as
well,
so
we'll
find
out
on
friday,
yeah.
D
Okay,
cool
yeah
yeah,
I
mean,
I
think,
I'm
guessing
like
there
are
people
in
both
the
collector,
like
alita
and
also
in
the
js.
Exactly
was.
E
D
Yeah
yeah,
I'm
gonna,
do
do
sick
meetings
always
go
an
hour
like
is
that
I'm
guessing.
D
E
All
right
I'll
add
this
to
the
to
the
zoom
today,
but
while
I
while
I
well,
I
write
this
to
the
notes,
not
the
zoom.
Do
we
want
to
finalize
like
sort
of
owners
for
either
certain
sections
or
certain
tasks
for
the
doc.
D
E
Okay,
so
you
said:
martin
you're
gonna
do
challenges.
Sorry,
just
writing
the
notes.
Yeah
yeah,
okay
and
santosh
you're
gonna
do
challenges
as
well
or
the
missing
functionality.
E
Why
don't
we
just
start
with
those
two
and
then
we'll
review
those
next
week
and
then
we'll
choose
owners
for
vision
and
how
to
achieve
this.
E
E
C
F
So,
who
from
here
has
done
any
browser,
I
think
martin
was
one,
but
is
there
anyone
else?
I've
used
google
analytics
before.
F
So
this
is
a
like
a
meta
kind
of
package
that,
like
combines
a
bunch
of
browser-specific
packages,
so
you
can
easily
like
install
it.
It's
not
splunks.
It's
open,
telemetries,
it's
under
contrib.
If
someone
wants
to
check
it
out,
I
just
use
it
to
show
you
what
packages
we
have
so
open.
Telemetry
has
a
web
tracer,
which
is
like
a.
F
So,
for
example,
we
have
an
instrumentation
from
for
document
load
which
capture
everything
is
expand,
so
document
load
captures
zone
spans.
Then
we
have
the
two
basic
ones
like
fetch
and
xhr,
which
I
guess
are
the
most
interesting
ones.
When
it
comes
to
data
that
users
want
to
capture,
they
want
to
capture
requests.
So
these
are
like
the
most
straightforward.
F
Everything
there
is
already
a
span,
so
they
also
make
sense.
The
document
load.
One
also
mostly
makes
sense,
because
you
can
kind
of
show
the
info
span
also
and
it
kind
of
makes
sense.
And
then
we
have
user
interaction
which
currently
captures
only
clicks,
but
you
can
quite
easily
expand
it
to
capture
like
any
interaction,
but
the
open
parameter
run
by
default.
Captures
clicks
like
mouse
clicks
and
that's
about
it.
For
the
big
packages.
F
There's
like
there's
two
kinds
of
context:
managers,
one
is
stack
context
manager
which
doesn't,
which
is
like
the
default
one.
If
you
don't
initiate
the
context
manager,
then
manual
tracing
only
works
with
synchronous
code.
So
if
you
create
anything
async,
you
cannot
connect
it,
and
for
that
there
is
like
his
own
context.
Manager
and
those
who
have
worked
with
browser
probably
know
their
c
zone.
Js
library
which
angular
uses
to
do
their
stuff.
F
So
for
page
like
them,
let's
start
with
document
load
plugin
like
instrumentation.
They
were
used
to
call
plugins,
but
then
they
were
renamed
to
instrumentation
to
match
the
spec.
So
some
of
the
code
still
has
a
word
plugin
in
it,
but
most
of
it
has
been
renamed
so
document
load
plugin
mostly
creates
three
kinds
of
spans.
One
is
document
fetch.
F
From
these
timings,
basically
that
browser
gives
you
creates
two
kinds
of
spends
fetch
and
document
load
like
one
of
it
has
like
half
of
the
timings
like
connect,
domain,
lookup
response
and
so
on,
and
the
other
one
has
timings
about
mostly
loading.
The
page
like
some
interactive,
don't
complete
and
so
on,
and
this
is
like
one
of
the
only
places
where
everything
is
under
one
trace.
Usually
every
span
is
a
separate
trace
like
you
can
see.
F
This
is
like
fetch
and
xhr
they're,
not
linked
to
the
parent
page
or
parent
page
trace
or
someone
so
and
how
document
load
does
it?
It
captures
every
resource,
that's
loaded
until
the
page
load
event
fires.
So
if
I
do
a
load
a
image
now,
then
it
will
be
a
separate
trace.
Well,
actually,
it
won't
work,
because
everything
that
happens
after
page
load
event
is
not
captured
when
it
comes
to
static
resources,
but
xhrs
and
fetches
are.
F
F
So
as
there
is
no
way
to
connect
all
of
these
spans
like
if
I
make
more
spans
the
user
interaction
plugin
also
like
connects
the
click
event
and
click
on
button,
I
do
a
request.
It
can
create
connect
that
click
and
that
request,
but
they're
not
connected
to
the
page
load
in
any
way.
F
F
I
think
it's
by
the
spec
it's
used
to
like
I'm,
not
actually
sure
what
the
spec
actually
says
about
it,
but
we
use
it
to
send
this
data
with
every
span,
because
everything
that's
in
resource
gets
added
to
every
span.
So
if
you
add
session
id
there
app
name
there,
every
span
will
have
it,
but
the
issue
with
resource
is
that
it's
supposed
to
be
static
like
if
you
initiate
it
initialize
it.
You
cannot
change
it,
but
we
do
actually
change
it,
but
you're
not
supposed
to
do
it.
B
F
B
A
You
mentioned
you
have
an
id
that
represents
the
browser.
Tab
right
is
that
same
as
the
instance
id
yeah.
That's
the.
A
Yes,
so
where
did
you
you
mentioned
currently
you're
representing
session
id
in
the
resource?
Where
is
it
here
from
287
to
295?
I
don't
see
what's
this,
but
that's
outside
of
a
resource
attribute,
so.
D
Yeah,
I
was
gonna
say
so
you
have
so
the
instance
id
spans,
multiple
page
loads.
F
D
H
F
If
you
yeah,
if
you
reload
it,
you
have
a
new
one,
it's
only
kept
in
memory.
Okay,
okay,
and
if
you
have
like
a
single
page
up,
you
do
a
lot
of
clicks
and
you
don't
reload
the
page.
Then
it
persists.
But
if
you
reload
the
tab,
it
goes
away.
So
only
thing
that
persists
is
the
session
id
which
we
keep
in
cookie.
So
it's
shared
between
all
types
under
the
same
domain.
D
Yeah
yeah,
like
one
of
the
someone
one
of
the
questions
in
my
mind
is
is
like,
is
whether
whether,
like
the
page
page
view
as
a
make,
makes
sense
to
represent
somehow
yeah.
We
have.
F
Like
in
my
head,
it
makes
sense
like
one
page
load
is
one
trace,
but
it's
not
easy
to.
Nor
does
any
everyone
want
to
do
it
this
way,
but
you
could
try
to
recruit
all
the
three
spans
under
one
trace
via
api.
Do
it
you
can
do
like
a
exact
trace
for
one
page
load
via
manual
api,
if
not.
D
Yeah
yeah,
I
think
we
would
be
running
into
the
issue
of
the
long-running
spans
there
or,
like
pages,
can
be
open
for
like
a
very
long
time.
I
You
know
so
so
in
the
in
the
initial
conversation
and
discussion
I
mean
we
always
had
the
point
that
that
it
should
be
possible,
maybe
to
have
spans
terminated
later.
So
this
probably
could
could
solve
a
lot
of
issues.
I
mean
you
could
do
the
same
with
sessions
as
page
loads
with
virtual
pages
and
all
those
things,
and
I
still
think
that
that's
a
very,
very
valuable
approach
to
it,
because
you
can
reuse
it
in
many
other
ways,
but
I'm
not
sure
if
this
is
doable
in
in
the
current
specification.
D
Yeah
and
like
I'm
yeah,
and
I
was
also
wondering
like
before,
you
even
went
down
that
road
like
if
it
if
it
makes
sense
to
even
represent
page
views.
That
way
because,
like
if
you
had
let's
say
like
a
span
that
that
goes
for
like
a
day
and
has
you
know
lots
of
lots
of
miscellaneous
small
spans
child
spans
like?
How
would
you
even
visualize
that.
F
Anyway,
okay,
so,
besides
that
capture
interactions,
well,
the
hotel
does,
and
then
we
capture
js
errors
and,
like
everything,
that's
not
a
span
gets
made
into
spam.
So
like
a
simple
example
for
it
is
to
web
vitals
which
are
kind
of
metrics,
or
maybe
events,
I'm
not
sure,
so,
basically
just
make
a
new
span,
and
then
we
set
some
attributes
to
it.
So
we
don't
use
the
duration
that
usually
spans
use.
We
just
add
values
as
attributes,
and
then
we
end
it.
So
it
has
zero
duration
and
it's
kinda.
F
A
Okay
and
the,
as
of
you
know
this
implementation,
the
only
thing
that
binds
them
together
is
that
session
id
right.
Yes,
because
in
your
head,
you
kind
of.
F
Want
to
connect
their
vitals
to
the
page
load,
because
page
load
has
a
big
impact
on
the
web
fighters,
but
apparently
it's
not
done
that
way.
So,
yeah
everything
you
create
is
a
separate
spin,
nah,
so
everywhere
vital
is
a
separate
span
and
separates
trace
id
with
no
parent
and
so
and
data
is
just
under.
F
It's
a
span,
it's
a
span,
yeah,
that's
the
you
could
in
theory,
like
the
other
two
you
could
make
into
like
spans
with
iteration,
but
for
cls
you
cannot
do
it.
I'm
actually
currently,
trying
to
upstream
it
and
I'll
see
how
it
goes
I'll.
Just
do
it
as
a
zero
duration
span
and
see
if
they
will
accept
it
or
not.
What
does
cls
stand
for?
I'm
sorry
cumulative
layout
shift,
so
it's
not
like
iteration,
it's
kind
of
a
score
like
0.12.
B
Yeah,
it's
worth
calling
out
that
at
the
moment
we
we're
using
zipkin
as
our
ingest
format
and
the
amount
that
this
the
shape
of
data
the
zip
code
can
represent
is
extremely
limited.
So,
when
we,
when
we
move
to
using
otlp,
eventually,
eventually
we're
going
to
have
a
lot
more
flexibility
in
what
we
can
represent.
B
It's
so
it's
worth
calling
out.
Martin,
when
you
were,
you
were
showing
that
error
span
so
we're
not
using
the
open
telemetry
conventions
there,
because
zipkin
doesn't
represent,
span
events
in
a
rich
way,
and
so
we
can't
actually
attach
the
error
as
a
span
event,
because
we
lose
all
the
information
except
the
name.
G
The
error
isn't
really
bound
to
any
real
real
span
that
it
would
belong
to.
It
happens
outside
of
any
anything
what
you
would
not
naturally
consider
as
a
spam.
B
F
A
So
it's
it's
only
relevant
to
apis
right,
not
to
the
other
type
of
events.
A
Yeah
requests
that
go
to
server
yeah,
so
the
trace
id
is
the
one
that
should
bind
them
right,
which
will
be
common
anyways.
G
I
guess
maybe
we're
zooming
out
for
a
moment
the
problem
here
and
why
what
martin
is
going
to
demonstrate
is
different
than
what
open,
telemetry
typically
does
open,
telemetry
propagates
context
from
top
level
to
top
to
bottom,
with
browser
ram
to
stitch
together
spans
from
different
services
with
browser
ram.
At
least
the
problem
is
with
the
initial
page
loads.
G
The
instrumentation
in
browser
is
not
yet
loaded.
So
when
the
page
load
fires
there
is
nothing
in
the
top
level
that
could
tell
to
the
bottom
level
that
hey
the
trace
id
is
x
and
span.
Id
is
y.
So
please
join
me,
so
it
happens.
The
other
way
around
and
martin
is
going
to
demonstrate
how
this
happens.
Okay,.
A
So
this
is
only
for
the
initial
page
right,
not
for
the
subsequent
pages,
as
in
when
you
type
a
url
in
the
browser
first
time.
You
know
that
is
the
one
that
now
every
page
load,
every
page.
F
G
For
unification
purpose,
or
maybe
at
least
currently
how
splunk
ram
works
is
that
it
works
similarly
both
for
xhrs
and
for
page
loads,
but
it
could
work
differently
for
x8
charge.
Yeah.
F
Okay,
so
for
the
initial
like,
if
I
load
the
page,
how
auto
current
work
is
like
the
meta
tag
is
inserted
into
the
page
and
then
the
instrumentation
and
in
this
metadata,
is
value
of
that
trace,
id
and
spin
id
of
that
request.
That
served
this
page
load
too,
and
so
that
the
meta
tag
is
queried
from
the
page
and
then
added
as
a
parent.
F
F
You
can
use
to
pretty
much
send
any
arbitrary
data
via
headers,
sometimes
in
browser
you're
going
to
do
it.
For
example,
there
is
no
way
of
getting
headers
of
the
initial
page
load,
there's
no
way
of
getting
headers
of
any
static
resource
like
an
image
load,
a
script
log
there's
like
no
way
of
getting
headers
of
these
requests.
You
can
get
it
as
for
xhr
and
fetch
requests,
but
you
cannot
get
them
from
like
static
resources
and
the
initial
base
load.
F
A
I
guess
it
looks
like
we
need
to
define
some
semantic
conventions
for
for
this
functionality,
right
which
so,
if
I
understand
this
correctly,
I'm
just
thinking
about
so
you
you,
you
visit
a
certain
website
for
the
first
time
and
therefore
you
know
your
client
side.
You
know
there
is
no
opportunity
to
to
start
a
span
yet
right.
A
There
is
no
trace,
there's
no
spam,
but
on
the
server
side
on
the
back
end,
let's
say
your
use
status
trace
there
right
and
that
in
the
response
header,
you
want
that
to
be
sent
back
to
the
browser
right.
A
So
is
the
trace
parent
supposed
to
be
present
in
the
response
headers,
I
thought
it's
only
in
the
request.
So
that's
one
question
I
have
and.
A
And
is
it
so
you
for
just
for
uniformity
sake,
you
you
suggest
using
this
mechanism?
Is
it
because
for
the
subsequent
calls
made
from
this
page,
let's
say
you
know
all
the
xhr
calls
made
from
this
page.
You
could
start
a
new
trace
right.
Would
you
be
using
that
mechanism
or
you
would
still
rely
on
a
server
sent
trace
id
in
the
transparent.
C
A
F
J
That's
a
a
standard
oas
who's
import
implementing
some
of
this
in
the
python
sdk
as
well.
I
just
also
want
to
call
out
there's
a
w3c
trace
response
header,
that's
in
the
draft
for
the
trace
date
spec
or
for
the
w3c
tracing
spec.
F
A
F
A
You
start
recording
because
there
are
resource
timing,
apis
that
tell
you
how
much
time
you
spend
on.
Let's
say
I
I
don't
know-
maybe
dns
lookup-
to
to
do
the
ssl
handshake.
A
So
all
those
you
know
you
need
to
start
recording,
so
you
would
assume
you
would
start
the
span
and
add
those
events
to
the
span
as
the
call
is
being
made
and
then
once
you
get
the
response
back,
you
have
the
trace
parent
and
you
take
the
trace
id
part
and
add
it
to
the
span.
Is
it?
Is
that
how
it
is
done?
Yes,
so
this
pen
starts.
F
C
F
F
D
F
F
And
ideally
if
because
this
header
isn't
actually
meant
for
this,
but
you
can
use
it
to
do
whatever.
Actually
any
arbitrary
data.
F
F
D
So
we
in
the
in
the
neural
instrumentation
browser
instrumentation,
like
we
generate
trace
id
for
every
xhr
call
currently,
and
we
do
that
in
like
in
javascript
in
in
code,
and
we
I
mean,
I
think
I
think
we
would
it'd
be
nice
like
if
you
could
defer
it
to
the
back
end
because
of
sampling.
D
Yeah,
I
think
I
think
ideally
it'd
be
nice
if,
once
the
trace
parent
response,
header
or
trace
response
header
gets
adopted,
that
would
be,
I
think,
the
ideal
solution
in
my
mind,
yeah
this.
F
E
So
I
added
two
more
items
to
the
agenda
that
we
can
close
up
with.
The
first
is
just
the
approach
to
what
we
probably
want
to
do
as
a
group
over
the
next
few
weeks,
setting
out
a
set
of
tasks
and
timelines,
so
in
the
doc
right
now
we're
defining
our
scope
and
our
goals
and
the
things
that
we
want
to
achieve
and
the
challenges
that
I
think
a
lot
of
people
already
face
with
rum
instrumentation
today.
We
also
will
need
to
define
over
time.
E
We
don't
need
to
do
this
this
week,
but
the
artifacts
that
we
think
we
need
to
produce
to
achieve
this
right,
and
so
this
this
is
effectively
like.
We
know
that
we
need
to
add
to
the
open,
telemetry
specification
to
define,
like
specifically
like
when
you
have
a
rom
client
and
what
we're
just
talking
about
when
a
request
goes
out
from
the
browser
like
is
that
traced?
Where
is
the
trace
context
generated?
What
format
should
it
be
in?
You
know
what
events
on
the
browser
should
be
recorded.
E
E
We
will
also
over
time,
need
to
find
semantic
conventions,
so
when
that
trace
is
recorded
it
should
it
should
also
have
these
annotations
and
this
extra
resource,
metadata
and
so
on.
That
is
the
core
output
of
this
group,
because
we're
not
we're
we're
effectively
setting
requirements
for
for
other
cigs
like
the
swift,
sig
or
the
javascript
sig
and
others
to
go
and
implement.
E
So
that's
what
we'll
need
to
do.
I
think,
as
we
talked
about
last
time,
I
think
long
term,
an
event
data
type
might
be
really
useful,
and
indeed,
I
think
for
people
who
wanted
to
work
on
profiling
and
some
other
aspects
of
open
telemetry.
E
They
wanted
this
as
well,
but
in
the
short
to
medium
term,
we
should
definitely
aim
to
use
the
existing
data
types
in
open
telemetry,
because
we
can
use
those
today
and
then
finally,
we'll
need
to
produce
a
plan
for
producing
those
artifacts,
and
those
artifacts,
of
course,
will
allow
us
to
achieve
our
goals,
and
so
the
doc
is
gonna.
You
know
over
the
next
few
weeks
we're
gonna
fill
it
in
with
basically
the
list
of
things
that
we
need
to
do
to
achieve
these
goals
that
we're
setting
up
in
the
next
week.
B
That
is,
that
hey
well
a
uses,
the
sdk
or
doesn't
use
the
sdk
and
only
uses
the
api,
but
also
where
that
instrumentation
should
live
like.
Should
we
create
separate
rum
based
instrumentation
repositories
for
android
and
ios
I
mean
maybe
the
ios
one
is
going
to
be.
Swift
makes
sense
because
it's
probably
the
only
place
where
people
are
using
swift,
but
certainly
for
java.
It
doesn't.
B
It
probably
doesn't
make
sense
to
to
shove
android
instrumentation
into
the
java
instrumentation
repository,
because
it's
a
very
different
sort
of
thing,
and
I
wonder
whether
the
same
thing
might
make
sense
for
browser
to
pull
that
out
into
a
separate
repository.
That's
all
based
around
building
rum
oriented
instrumentation.
G
E
All
right-
and
I
will
copy
this
into
the
top
of
the
the
plan
document,
just
because,
as
notes
it'll
get
pushed
to
the
bottom
very
quickly,
so
that
we
can
reference
it
for
the
next
few
weeks.
E
This
document
needs
to
define
okay
and
finally,
this
came
up.
Actually
in
last
week's
governance
committee
call,
there
was
a
request
that
this
group
changed
its
name
from
rum
to
say,
like
client,
instrumentation
or
something
just
because
I
think
some
analysts
had
reached
out
to
ben
and
a
few
others
on
the
governance
committee.
Saying
oh,
is
open.
Telemetry
now
going
to
do
back-end,
processing
of
rum
event
data.
E
I
saw
there's
a
rum
group
and
the
answer
is
no,
but
there
was,
I
think
the
confusion
was
that
rum
often
delineates
like
an
end-to-end
solution
as
opposed
to
capturing
client
telemetry.
Would
we
be
okay,
changing
our
name
to
something
like
client,
instrumentation,
client
telemetry?
I
don't
have
a
good
suggestion.
D
E
B
E
E
A
I
had
one
comment,
so
the
logs
specification
explicitly
calls
out.
You
know
events
as
being
same
as
logs,
so
is
there
any
discussion
that
needs
to
happen
with
the
logging
sync.
E
B
A
D
E
So
I
I
talked
to
daniel,
so
it
sounds
like
in
a
week
we're
gonna
have
someone
from
the
js
sig
joining.
I
was
at
the
maintainers
call
this
week,
which
I
lead.
There
was
no
one
from
the
swiss
sig
this
week,
so
if
they
don't
attend
next
week,
then
I
will
reach
out
to
them
directly.
B
E
B
Certainly,
what
we've
found
in
the
past
few
months
is
that
there
are
a
lot
of
things
that
are
very
different.
The
model
is
very,
very
different,
so
figuring
out.
If
we,
this
is
another.
I
guess
this
is
another
big
question
we
need
to
tackle
is
how
much
are
they
different?
How
much
is
there
in
common?
How
much
are
we
going
to
be
doing?
There
are
going
to
be
things
that
are
similar
and
the
same,
but
there
are
also
things
that
are
very
different
in
the
mobile
world
versus
the
web
world.
A
B
Yeah,
if
people
want,
I
can
show
really
quickly.
I
could
share
my
screen
and
show
a
little
bit
about
the
the
kind
of
spans
that
we're
generating
on
android,
because
that
could
be
interesting.
Let
me
quickly
do
it
I'm
not
going
to
go
into
a
huge
amount
of
detail
on
the
exact
hold
on
a
second
find
the
right
right
browser
of
the
many
many
many
browsers
I
have
open
and
I
will
just
choose
one
all
right.
So
can
you
see
so
this
is
our
android
instrumentation
repository
just
fyi,
it's
open
source.
B
Anyone
can
take
a
look,
but
I
just
wanted
to
show
a
little.
This
is
in
using
our
ui,
the
splunk
ui,
but
these
are
just.
They
are
just
stands,
so
I
just
wanted
to
kind
of
point
out
the
kinds
of
things
that
we're
generating
right
now,
so
one
thing
that
we're
doing
is
tracking
like
app
start
time,
so,
the
actual
time
it
starts
for
the
application.
B
What
for
the
application
to
start
up,
which
is
actually
incredibly
difficult
to
actually
figure
out
what
that
means
I'll
just
say
on
mobile,
like
what
does
it
mean?
When
is
the
application
ready
right
now?
In
android,
we
assert
that
it
means
when
the
the
first
activity,
so
an
android
screens
are
organized
into
activities
and
fragments.
When
the
initial
activity,
the
first
activity
is
created,
completes
its
life
cycle,
then
we
say
that
that's
the
end
of
the
application
startup.
B
This
is
not
always
true.
This
is
not
always
appropriate.
We
certainly
have
feedback
both
internally
and
externally,
that
you
know
people
would
like
to
be
able
to
custom
customize
what
it
means
for
application
start.
So
this
is
something
we
we
haven't
solved,
but
it's
something
we've
been
thinking
about.
B
B
This
is
a
bad
example:
yeah.
We
generate
open,
telemetry
events
for
all
of
the
different
pieces
that
are
happening
inside
this
initialization
cycle,
for
example.
B
So
you
can
see
some
things:
resource
initialized,
open,
telemetry,
sdk
initialize,
so
we
track
all
that
kind
of
as
span
events
and
those
do
get
turned
into
zipkin
logs,
but
they're
very
sparse.
They
don't
get
a
lot
of
information
out
of
them
and
then
we
also
track
the
amount
of
time
it
takes
to
create
the
activities
and
fragments
that
are
that
are
made
up.
So,
for
example,
we
also
have
internal.
We
have
access
to
android
apis
with
all
of
the
internals
of
what
happens
with
the
activity
startup.
B
I
don't
know
exactly
what
the
api
is
called,
but
there's
a
way
you
can
monitor
for
network
changes,
so
we
actually
track
those
as
well
and
display,
for
example,
that
in
this
particular
case
somewhere,
it
says
wi-fi,
oh
yeah,
so
that
we
actually
got
a
wi-fi
became
available.
As
a
so
that
was
an
event
that
happened
during
the
life
cycle
of
the
startup.
B
I
guess
it
wasn't.
During
start
it
was.
It
was
not
connected
to
startup,
but
it
happened.
You
can
see
timing-wise
during
the
startup
process,
so
that's
the
sort
of
stuff
that
we're
tracking
right.
Now
we
also
you
know.
As
we
talked
about
talking
about
some
https,
we
have
http
instrumentation,
we've
just
pulled
in
the
java
java,
http,
okay,
http,
client
instrumentation,
and
we
you
know
we
get
the
usual
open.
B
This
is
100
open,
telemetry
data
like
all
the
scientific
conventions,
because
because
we're
just
using
the
open,
telemetry
java,
instrumentation
for
ok,
http
and
plugging
it
in
so
that
is
the
kind
of
stuff
that
we're
getting
out
of
the
instrumentation
at
the
moment.
D
So
john,
these
are
these
fragments.
Are
they
synonymous
with
like
page
views.
B
And
ish,
I
would
say
they
are
not
synonymous.
They
are
slightly
different.
For
example,
one
of
the
things
this
nav
host
fragment
is
actually
an
internal
fragment
in
the
in
the
end,
in
one
of
the
android
frameworks
that
actually
creates
navigation
flows.
So
there's
a
fragment
created
there,
but
it's
never
something.
That's
actually
visible
to
a
user.
You
know
it
happens.
It
is
used
to
coordinate
the
movement
between
other
fragments.
D
B
So
sort
of
a
fragment
is
often
synonymous
with
a
page
with
a
screen
in
your
app,
but
not
always
and
activities.
The
fragments
are
kind
of
the
newer
model
for
android
ui
development.
There's
the
older
one
is
the
activities
which
you
still
are
required,
but
generally
the
recommendation
now
is
that
activity
should
have
multiple
fragments
that
are
stitched
together
with
these
nav.
These
navigation
fragments.
B
No,
no,
not
at
all
an
activity
activity
is
a
screen,
but
a
fragment
is
also
a
screen.
That's
why
I'm
saying
it's
com?
It's
not
there's
not
a
one-to-one
relationship,
okay,
because
activity
may
have
many
fragments
associated
with
it
and
that's
all
coordinated
by
this
nav
post
fragment
thing,
but
in
the
older
model
of
android
development,
like
the
initial
the
early
early
days,
android
development
activities
were
exactly
synonymous
with
the
screen,
so
it
has
changed
recently
or.
A
A
B
Recent
it's
been
many
years,
but
there
are
still
activities
under
the
hood
for
these
kind
of
big
chunks
of
user
interface,
multiple
screens
that
are
kind
of
all
coordinating
a
similar
sort
of
action.
That's
going
on,
but
no
an
activity
is
definitely
not
a
user
interaction.
That's
a
screen
or
a
group
of
screens.
B
Similar
but
of
course,
there's
no
activities
and
fragments
in
ios
because
it
has
a
completely
different
ui
model.
So
this
is
where
things
get.
It
starts
getting
really
complicated,
because
the
ui
models
on
the
browser
on
android
and
ios
are
all
quite
different
and
we're
not
even
tackling
react
native,
yet
yeah
or.
B
So
yeah
this
is
this,
is,
I
think,
a
lot
of
where
our
challenge
is
going
to
be
in
this
group
is
figuring
out
how
to
build
a
unified
model
for
all
of
these
things,
because
they're
definitely
do
not
work
the
same
way
across
all
of
these,
and
you
don't
have
access
easy
access
to
instrumenting.
A
B
A
Okay,
so
then
the
what
needs
to
be
done
is
to
define
the
semantic
conventions
right
for
how
to
uniformly
represent
these
elements
across
all
platforms.
Yeah.
C
A
E
And
I
think
we're
that's
a
wrap
so
martin
and
santosh,
I
think
you've
got
you're
going
to
take
point
on
those
two
sections
of
the
dock
and
we'll
review
it
next
week
sounds.