►
From YouTube: 2022-06-29 meeting
Description
cncf-opentelemetry meeting-2's Personal Meeting Room
A
B
Okay,
so
I
had,
I
had
just
a
couple
of
things
that
have
been
on
my
mind
and
I
wanted
to
discuss
with
the
group
or
get
your
feedback
doesn't
seem
like
other
people
that
had
opinions
on
this
are
attending
today,
though,
so
I
might
have
to
circulate
offline
as
well,
but
the
two
topics
that
I
that
I
have
had
is
one
just
talk
about:
when
do
we
use
events,
and
when
do
we
use
spans.
B
And
then
the
other
one
is
continuing
the
discussion
on
timing
events
and
with
with
I
think
the
initial
focus
I
haven't
is
on
the
navigation
timing.
D
Yeah,
I
guess
I
can
jump
in
with
my
thoughts
on
those.
So
in
terms
of
when
to
use
the
new
log
events
versus
spam
events.
I
think,
ultimately,
we
want
everything
everything
to
be
a
log
of
it
and
at
some
point
we'll
want
the
span
event
to
effectively
just
generate
a
log
event
under
the
covers.
But
part
of
that
is
this
nesting
attribute
issue
which
I'm
not
getting
a
lot
of
good
traction
on
people
are
pushing
back
on.
D
So
if
we
can't
get
nested
attributes
supported
in
spans
or
even
span
events,
but
then
log
events
is
the
only
path
forward.
D
Like
spain,
events
are,
for
our
purposes
have
been
a
stop
gap
like
for
the
events,
I
think
we're
going
to
define
here.
I
think
they're,
we're
probably
going
to
mainly
think
a
lot
of
events.
There
may
be
some
cases
for
simple
events
which
are
just
hey.
This
thing
happened.
B
D
A
span
event
would
down
would
make
sense,
but
I
think,
as
long
as
we
can
have,
the
the
log
event
have
a
link
to
the
current
span
so
that
the
back
end
can
stitch
together.
I
think
that's
that's
pretty
the
main
thing
we
need
to
do,
which
I
think
the
santosh
was
having
in
his
his
spec.
B
Yeah
so
so
I
think
a
couple
of
things
there,
like
santosh,
mentioned
to
me
that
he
was
concerned
about
if
we,
if
he
send
them
as
two
separate,
if
he
sends
spans
and
the
events
as
two
separate
payloads,
then
the
back
end
will
have
to
wait
for
them
to
to
come
I'll.
B
D
And
that's
going
to
happen
because
effectively
spans
don't
send
until
they
end.
So
if
a
span
never
ends,
you
effectively
lose
everything
so
yeah.
There
is
no
easy
solution
for
that.
So.
B
Yeah,
so
I
have
some
some
notes
in
in
the
timing
deck
I'm
going
to
share
it.
If
you
don't
mind.
D
B
B
B
So
if
you,
if
you
think
about
like
currently
the
the
current
instrumentation
for
document
load,
creates
spans,
for
that
represents
the
the
navigation.
B
You
know
the
loading
of
the
page,
yep
right
so
and
then
there's
so
it
is
created.
Well,
I'm
just
going
to
create.
Let
me
share
my
screen.
B
Yeah-
and
I
so
I've
been
to
be
like
to
be
honest,
like
I've
been
thinking
about
this,
I'm
sorry,
I'm
not
I'm
not
gonna,
I'm
not
I'm
not
gonna,
say
like
to
do
it
one
way
or
the
other
I'm
just
like
presenting
like
the
options
here,
but
I've
been
I've
been
thinking
about
it
until
recently
that
we
should.
We
should
essentially
send
everything
as
events
and
and
then
like.
If
you
want
to
do.
B
If
you
want
to
do
some
tracing
in
the
client,
either
like
to
connect
the
backend
or
to
actually
trace
code
in
the
client
applications,
then
you
would
use
spams
and
and
they're.
Also
very
much,
in
my
mind,
relates
to
the
semantic
conventions
discussions
we've
been
having,
because
you
know
we
have.
You
know.
I
know
that
there
have
been
some
folks
that
have
been
that.
You
know
that
it's
important
to
do
that.
We're
saying
that
it's
important
to
do
validation
on
the
back
end
of
events.
B
So
if
we,
if
you
send
some
things
as
as
events
and
some
things
as
fans
like
the
semantic
conventions,
are
gonna
be
work
differently
for
spans.
So
so
now
like,
how
do
you
do
validation
of
spans?
You
know
if
that's
important,
I
don't
know
if
that's
important.
So
with
that
said
I
I
started
looking
at,
I
like
the
navigation
timing
first
and
so
the
current.
B
You
know
you
I'm
sure
all
of
you
are
familiar
with
this,
but
the
current
implementation
creates
plans
for
document
load
and
then
the
the
resource
fetch
the
resource,
fetch
and
document
fetch,
and
then
it
creates
like
the
strike,
the
the
tree
structured.
It
links
to
spans-
and
I
think,
that's
useful
for
sure
useful,
because
it
shows
you
attribution
of
which
resources
affect
the
document
load.
B
B
It's
also
the
one
concern
right
hyphens.
Another
concern
that
I
have
is
that
they're
not
reliable
like
it's,
it
depends
on
the
window
load
firing.
B
So
if
window
load
doesn't
fire
like
user
leaves
before,
then
you
lose
that
that
information
now
you
could
get
around
it
in
the
instrumentation,
maybe
like
we
could
create
the
span
when
even
like
in
the
unload
event.
But
you
know
you
know,
I
think
creating
spence
is
a
little
bit
more
expensive
and
emitting
event.
In
my
opinion,.
D
D
So
this
is
where
the
ted's
ephemeral
resources
might
help
a
little
bit
with
that.
So
at
least
the
sdk
is
partially
initialized,
but
yeah
there's,
there's
timing
issues.
D
Effectively
because
of
its
current
implementation,
everything
will
happen.
I
think,
on
the
next
javascript
execution
cycle,
because
initializing
implementations
is
always
asynchronous.
There
is
a
pr
out
which
I
haven't
actually
looked
at
the
detail
of
it,
but
effectively
it
will
potentially
return
a
promise
or
just
say
it's
okay,
to
try
and
address
this.
D
I
link
to
ted's
ephemeral
spec
on
on
that,
but
haven't
had
a
chance
to
go
through
it
once
that
merges
because
it
seemed
pretty
high
that
it
was
going
to
merge.
Then,
as
long
as
you
don't
have
an
asynchronous
instrumentation
being
installed,
I
either
do
a
background
fetch
to
go
and
get
metadata.
D
It's
stuff
like
that.
There's
it's
in
the
in
my
to-do
list
to
investigate
in
the
sandbox,
because
in
the
sandbox
we're
going
to
be
able
to
just
hack
these
things
and
try
them
out
a
bit
faster
than
what
we
can
today.
B
B
Okay-
and
so
let
me
just
continue
here
so
the
and
the
other
thing
that
I
mentioned
already,
is
that
you
know
if
it's
important
for
us
to
identify
the
the
telemetry
coming
from
from
the
client
side
from
the
client,
then
spence
spans
would
be
identified
in
differently
than
than
events
like
we're
currently
proposing
that
events
are
going
to
be
identified
by
the
combination
of
name
and
domain,
whereas
spans
would
be
like
the
old
model,
which
is
just
presence
of
some
attributes
right.
B
So
I
don't
know,
I
don't
know
if
that's
a
concern
for
some
folks,
and
we
might
need
to
think
about
like
if,
if
you
decide
that
certain
types
of
data
are
gonna
continue
being
expands,
then
we
may
need
to
think
about.
You
know
defining
semantic
conventions
for
those
that
so
that
we
can
identify
those
spans.
D
Yeah,
I
think
today
it's
been
a
while,
since
we've
looked
at
the
document,
loading
resource
fetch
code,
but
really
the
the
span
is
just
the
transport
vehicle.
It's
really
just
the
event
within
the
span.
That's
really
where
the
meters,
so
while
there
there
is
a
level
of
semantic
convention
it
really
it's
it's
just
like
we're
using
logs
to
transport
that
just
create
the
zero
length
span
to
get
it
apart
from
that
resource,
I
guess
but
yeah.
I
I
get
where
you're
coming
from.
B
Yeah,
so
so
like
I
just
so
just
looking
at
this
navigation
timing
or
like
navigation
events,
if
you
wanted
to
capture
information
about
the
navigation
timing
and
also
that
navigation
occurred
so
like
the
use
cases
getting
throughput
and
and
navigation
timing,
so
the
options
that
I
could
that,
obviously
that
I
can
think
of
is
not
number
one
either
keep
it.
Keep
it
as
a
span
as
currently,
and
I'm
not
going
to
go
through
all
these
details
or
or
the
or
capture
it
as
a
navigation
event.
B
So
the
navigation
event
would
be
just
that
it
just
maps
to
the
network,
the
performance,
entry,
navigation
performance,
entry
event
that
comes
from
the
api,
and
it
just
would
list
all
the
values
as
attributes
or
maybe
like
what
you're
saying
that
would
be
combination
like
we
could
have
a
span.
That's
used
for
you
know
linking
to
other
spans.
So
you
can
see
the
the
relationship
between
different
things
that
have
duration.
D
So
if
you've
got,
if
you
have
a
spa
and
you've
got
some
sort
of
router
which
takes
some
time
to
go
fetch
some
stuff,
then
it
would
make
sense
to
create
the
span
any
event
that
fires,
while
that
span
is
happening,
gets
tagged
as
part
of
that
there
is
some
gotchas
there,
but
because
it
could
be
unrelated
events
and
then,
when
the
navigation
finishes,
you
you
end
the
span
so
therefore
anything
any
back-end.
D
D
That's
something
else
we
should
look
at
as
part
of
the
unload
of
the
page.
How
can
we
force
any
active
spans
to
effectively
terminate?
I
haven't
even
investigated
that
part
of
the
code,
yet.
B
Yeah,
I
mean
the
initially
that
what
I
was
thinking
is
again,
like
the
use
case
being
I
I
want
to
know
the
throughput
reliably
and-
and
I
want
to
get
at
least
some
data,
even
if
not
not
everything
is
available.
I
wanted
to
get
some
data
about
the
timing
that
was
available
at
the
time.
The
page
ended
so
like
with
the
navigation
event.
B
You
know
like
when,
when
when
you
select,
you
use
the
performance
of
observer
or
you
when
the
window
load
even
fires,
you
you
can
generate
the
event
with
all
of
the
timing
data.
If,
if
it
doesn't
happen
and
the
win,
the
unload
happens
first,
then
you
can
still
use.
You
know,
get
the
navigation
timing,
data
from
from
the
api,
with
some
values
that
that
happened
until
up
to
that
up
to
that
point
and
collect
them
right.
So
that's
much
easier
than
dealing
with
the
span,
but.
B
B
Yeah
so
capture
single
event,
navigation
event
that
mirrors
the
the
attributes
from
the
performance
navigation
timing
interface.
So
you
know
in
that.
In
that
sense,
like
I
don't
I
don't
think
I
don't
even
know.
I
don't
even
think
that
we
would
necessarily
need
to
define
semantic
conventions
for
all
the
attributes
in
performance,
navigation
timing.
B
B
And
then
capturing
the
page
load
life
cycle
as
spans
can
can
still
exist.
In
my
opinion,
it
could
be,
you
know,
work
together
in
the
same
instrumentation
or
it
could
be
a
separate
plugin
that
and
these
two
things
can
work
together.
D
Yeah,
I
guess
there's
two
cases
of
page
load
here.
So
if
we're
just
talking
about
the
page
load
event,
that
really
is
just
an
event.
If
we're
talking
about
your
application
and
effectively
as
part
of
initializing
your
app
and
you
want
to
track
all
that.
That
makes
sense,
because
that's
where
I
logically
think
of
that,
as
potentially
asynchronous
operations.
So
if
something
is
asynchronous,
then
it
would
probably
make
sense
to
have
a
span
that
wraps
that
as
a
grouping
mechanism,
that's
generally
my
my
gut
of
when
to
use
spans
and
when
not
to
use
fans.
B
Yeah
yeah,
I
mean
there's
a
so.
There
are
things
you
might
still
want
to
to
analyze
like
what
what
things
contribute
to
like
long
page
load
yeah.
So
if
you
have,
if
you
have
resources
that
take
a
long
time
or
if
you
have
ajax
calls
to
happen
during
the
page
load,
you
can
you
know
creating
like
the
the
span
span
tree,
I
think,
might
be
useful
because
you
could.
You
could
say
this.
This
resource
took
a
long
time
and
therefore
the
page
load
was.
D
C
B
And
you
know
again,
like
I,
I
think
I
think
martin
martin
is
on
the
call
t2
like
was
was
was
talking
about
this
in
the
chat
in
slack.
B
B
I
I
think
there
is
probably
some
some
usefulness
to
it.
If
you,
if
you
wanted
to
say
like
this
resource
is,
is,
is
pushing
the
window
load
event
further
out.
D
Yeah,
I
could
see
some
people
wanting
that
and
some
people
not
which
is
from
an
sdk
perspective.
I
I
always
try
and
be
flexible
to
handle
what
people
want
to
do
and
yeah
so
yeah.
You
know
in
some
cases
for
some
applications
yeah,
but
the
first
thing
comes
to
mind
is
just
all
the
extra
overhead
involved
in
creating
the
spams.
That's
how
there
is.
There
is
a
limit
I
think
by
default.
D
I
don't
know
if
you
can
change
this
one
of
128
events
for
a
span,
but
if
we're
just
saying
we're
going
to
record
them
as
long
events
anyway
and
link
them
to
the
span,
you
know.
If
someone
wants
to
do
that,
then
we
either
have
the
instrumentation
create
the
artificial
span,
or
so
you
have
one
that
does
one
that
doesn't
or
one
that
does,
that
has
a
config
setting
to
say
who
wants
to
do
that
yeah?
D
D
Yeah,
that's
that's
the
fun
bit
because
the
log
code
doesn't
exist.
Yet
my
understanding
and
I
haven't
read
the
spec
in
detail-
is
the
fact
it
uses
the
context
to
figure
out
whether
it
should
attach
the
the
span
trace
id
to
the
log
event.
That's
just
by
attending
the
log
meeting,
though
this
listing
how
that
was
gonna
operate.
D
How
you
do
that,
I
I
don't
know
in
terms
of
javascript
today
it
doesn't
exist,
so
I
know:
do
you
have
any
martin?
Do
you
have
any
more
context
on
that.
E
E
But
one
use
case
with
this
page
slow
spend
the
customers,
usually
they
want.
They
know
when
the
page
load
ends.
They
have
some
kind
of
event,
whatever
router
chains
and
or
whatever,
and
their
issue
is
usually
that
they
want
to
create
this
custom
span,
but
they
want
all
the
instrumentation
spans
to
go
as
children
of
that
custom
span,
but
they're
currently
unable
to
do
it
because,
there's,
like
the
context,
doesn't
propagate
it.
D
E
B
B
Yeah,
so
so
this
is
the
this
is
the
current
span,
that's
generated
the
document
load
and
what
we
do
is
what
it
does.
It
adds
these
span
events.
B
So
for
each
each
thing
from
the
navigation
timing,
I
think
it
creates,
as
an
a
separate
event
span
event.
So,
instead
of
this,
we
would
have
a
separate
log
log
event.
The
name
would
be
navigation
and
then
it
would
have
attributes.
Instead
of
you
know,
multiple
attributes
for
all
these
things
for
all
these
different
timings
and
that
that
event
would
be
tied
to
this
document
mode.
So
all
these
spam
events
would
go
away.
D
Yeah
yeah
because,
like
at
the
moment,
this
is
an
implicit
semantic
convention.
By
saying
when
the
trace
name
is
document
load.
We
have
all
these
events
because
you
could
have
those
event
names.
F
So
quick
question
the
timing
of
when
this
the
the
proposed
event
fire
would
be
after
the
unload
event,
ends
right.
F
Now
we're
capturing
unload
event,
as
you
know,
relevant
as
as
an
attribute
or
a
separate
event,
or
anything
like
that.
That
means
we
have
to
wait
until
that
happens.
Typically,
that
happens
when
the
page
is
about.
You
know
which
unload.
D
F
E
Can
you
open
it
the
unload
event
and
then
the
end.
B
But
if
you,
if,
if
the
load
event
does
not
fire
or
like
you,
the
page
unloads
goes
away
before
you
know
some
of
these
events
fire,
then
you
can
still
get
partial
set
of
these
attributes.
F
Okay,
I
I
think,
there's
still
probably
a
hole
right.
You
know
if
that's
the
last
page,
the
unlock,
the
page
crashes
or
something
there's
no
next
page
to
go
there.
So
essentially,
the
previous
pages
in
four
is
lost
right.
So
that's
what
I'm
confused
about!
Maybe
that's!
It's!
It's
been
a
long
time.
Nev.
Isn't
there
an
opportunity
to
lose?
Events
on
you
know,
you're,
navigating
a
series
of
pages
in
a
website
the
last
of
the
page.
F
D
Well,
this
the
event
we're
currently
looking
at
is
when
the
when
the
current
page
is
loaded.
This
is
what's
available
in
the
navigation
timing,
so.
F
That's
a
non-complete,
you
know
don't
complete
their
fighting,
that's
the
point
when
we
would
generally
be
recording
this
effects.
Correct.
D
Correct
yeah,
so
so,
if,
if
you
actually
hit
this
page
at
the
very
first
page,
you'll
probably
find
the
unload
event
start
and
end
wouldn't
be
there.
D
A
So
I
have
a
question
here
on
the.
A
On
the
traces
from
the
documentary
traces,
so
do
you
like?
Can
you
include,
for
example,
navigation,
start
to
the
to
the
list
of
metrics
or
to
the
list
of
markers
navigation,
markers
and
also
is
the
document
fetch
like
there
is
a
document
feature
span
is
a
separate
spawn.
Some
of
the
navigation
metrics
are,
I
mean
just
to
indicate
somewhat
to
get
some
performance
from
the
like
document
load
event.
We
also
need
some
of
the
events
they
are.
Can
they
be
combined
together
or
do
they
have
to
be
separate?
B
Do
you
mean
the
resource
timing
attributes
on
for
the
document
fetch
yeah
yeah.
E
B
Yeah,
I
mean
sorry,
I
think
that
that
actually
leads
to
my
my
next
next
question
too,
which
so,
like
I
think,
the
nets
like
the
navigation
timing,
like
that's
that
was
my
proposal
and
have
that
have
just
the
attributes
of
navigation
timing,
which
would
be,
I
think,
actually
it's
a
good
clarification.
It's.
It
would
be
just
the
attributes.
Let's
see.
B
So
I,
when
I
was
proposing
the
navigation
event,
I
was
thinking
of
only
the
navigation,
specific
attributes
and
and
then
like.
I
guess
my
that
leads
to
your
question,
which
is
how
how
do
resources
in
general,
maybe
maybe
like,
do
we
need
to
do?
We
need
to
discuss
this
as
a
kind
of
general
resources
question,
or
is
it
tied
to
the
navigation
timing
so
for
for
resources,
I
was
thinking
so
my
question
is
like
do
we
want
to
do?
We
want
to
capture
these
resources
as
spans
or
as
events.
D
B
D
And
that
way
you
know
in
terms
of
unloading
and
we
have
the
64k
limit.
At
least
we
should
be
able
to
get
some
of
these
out
of
the
door
and,
at
some
point,
we'll
grow
some
sort
of
like
local
storage
session
storage,
persistence
in
whatever
framework
so
that
when
they
come
back
in
anything
that
didn't
get
sent
from
the
previous
run
will
get
sent
to
the
new
one
and
because
they're
smaller
chunks,
it's
just
easy
to
get
get
them
off.
The
browser.
B
B
That
makes
sense
to
me
what
what
does
everyone
else
think.
B
I
think
the
same
structure
of
spans,
but
instead
of
having
span
events
on
those
spans,
we
would
generate
a
separate
span,
separate
log
events.
They
would
they
would
link
to
those
spans.
A
Okay,
so
the
events
are
separately:
santiago,
yeah,
okay,
so
you
link
them
through
the
spawn
id
or
yeah
trace
id
and
spam
id.
F
And
just
just
for
that
sorry
I'll,
let
you
go.
I
thought
you
had
a
question.
A
D
Yeah,
it's
defined
on
the
performance
timing,
but
the
page
I'm
looking
at
says
it's
deprecated,
it's
no
longer
recommended,
but
yeah
it
really
the
way
we're
defining
the
events
for
these
things
is
if
the
browser
gives
it
to
us,
it'll
be
included.
A
B
D
Yeah,
but
I
I
think
the
general
approach
that
I
think
we're
taking
is
as
part
of
the
performance
timings.
We
will
identify
what
the
w3g
says,
but
if
the
browser
provides
additional
because
I
could
add
new
ones
in
the
future,
they'll
just
end
up
being
included.
So,
if
you're
running
in
a
in
an
environment
where
the
browser
supplies
navigation
start,
I
would
expect
navigation
start
to
be
present
if
the
browser
supplies
it.
If
it's
not,
that
won't.
F
Okay,
so
clarification
for
this
resource
events
that
we
were
talking
about
right.
Are
we
saying
for
every
resource
on
the
page,
there
will
be
an
event
that
we
will
fire.
D
F
D
They
could
yep,
so
the
other
option
would
be
that
we
affected
group.
So
in
fact
we
could
construct
a
general
resource,
one
that
has
an
array
so
as
part
of
the
event
data
it's
instead
of
being
a
single
one.
It's
a
an
array
or
a
group
of
them,
but
size-wise
for
the
individual
event.
That's
going
to
get
problematic,
correct.
F
The
couple
of
things
you
know,
I'm
just
talking
from
memory
about
with
the
old
implementations
we've
had
is
the
resource
data
capture
was
turned
off
by
the
phone.
If,
if
customers
really
want
that
data,
they
turn
it
on
and
then
the
problem
that
we
ran
into
was
the
the
event
limit
being
consistently
hit
and
we'll
eventually
not
be
able
to
send
anything
at
all
which
would
never
solve,
but
we
got
to
come
up
with
some
way
of
chopping
up.
F
The
the
resource
timing
object
an
array
and
then
some
some
interesting
way
of
chopping
up
the
stuff
or
or
consolidating
or
whatever.
We
should
probably
define
that
if
we
are
saying
resource,
you
know
whether
or
fire
these
events
either
we
separate
we
fire
them
separately,
in
which
case
it's
noisy
are
we
grouping
them?
We
still
have
to
think
about
chopping
them
up,
because
that's
definitely
going
to
hit
the
limits.
The
injection
limit
for
each
event.
B
So
there
are,
there
could
also
be,
obviously
it
could
be
a
separate,
instrumentation
or
plug-in.
So
it's
optional,
yeah,
yeah
and
the
other
thing
is,
is
we
could
we
could
potentially
have
like
feature
specific
sampling.
B
I
use,
I
don't
know
like
what
I
don't
know
like
what
what
the
use
cases
are
for
capturing
all
resources.
I
don't
know
if
it's
if
it's
really
useful
yeah.
E
Can
be
useful
when
you
look
at
the
waterfall
view
you
can
see
like
you
can
have
only
so
many
resources
loading
at
the
same
time,
so
you
can
have
this
parallelization
problem.
It
used
to
be
like
eight
on
some
browsers
and
if
you
look
at
the
waterfall,
you
can
see
that
okay,
these
eight
are
blocking
those
next
ones
and
so
on.
E
D
E
D
And
yeah
you're
right,
it's
like
your
browsers,
have
a
limit
which
is
well
in
fact,
there's
several
limits.
It's
per
domain,
which
I
think
originally
it
was
four
a
bit.
I
think
you're
right.
I
think
it's
eight
now
and
then
it's
depending
on
the
run,
the
whether
you're
in
linux
or
windows,
there's
actually
a
maximum
number
of
connections
that
the
browser
will
make
regardless
of
domain.
B
Yeah
but
the
buffering
right
but
yeah
yeah,
but
with
perf
observer
you're,
fine.
D
D
I
I
guess
you
might
want
that
optionally,
but
it's
mostly
during
development
you'd
worry
about
that,
but
we
can
support
it,
as
martin's
already
said,
with
having
an
instrumentation
to
do
it
so,
but
I
would
hesitate
to
recommend
that
as
the
standard.
E
Yeah,
it
most
definitely
will
be
a
separate
instrumentation
yeah
as
it
currently
is.
For
us,
it's
just
whatever
happens
after
load
event.
Is
it's
all
right.
D
B
Okay,
so
I
think
for
for
these
two
for
resource
and
navigation,
I
might
update
the
the
pro
the
prototype
that
we
have
so
then
I
can
circulate
so
people
can
have
a
look.
What
it
actually
looks
like
just
for
double
checking.
D
Yeah
right,
I
think
I've
already
put
down,
put
it
all
down
there
so
effectively,
I've
got
a
very
basic
version.
Working
I
haven't
dragged
in
any
of
the
examples
or
any
of
the
experimental
packages.
It
really
is
the
very
basic
set
that's
needed
to
build
the
the
s
the
web
sdk,
the
this
one's
currently
failing,
because
it's
failing
to
install
russia
on
the
in
git,
but
you
see
it's
like
637
files.
D
So
when
I
I
did
actually
push
this
out
to
the
sandbox
and
then
hit
all
these
issues,
so
I
I
shut
that
one
down,
so
it's
just
locally.
Now
in
my
in
my
fork,
I
I
think
with
daniel.
He
says
this
is
effectively
un
unreviewable,
so
it's
like,
while
I've
automated
it.
D
If
you
scroll
down
in
the
scripts,
there's
a
a
thing
called
merge
repo
so
expect
it's
a
javascript,
a
node
script
that
I've
created
to
effectively
as
long
as
you
have
an
api
and
a
js
repo
locally,
it
will
effectively
copy
over
the
bits.
Well,
hopefully,
it's
in
there
it's
in
there
somewhere.
So
what
what
I'm
currently
working
on
is
effectively
trying
to
create
a
script
that
will
merge
the
repos
keeping
all
of
the
history,
because
at
the
moment
this
script
doesn't
it's
affecting.
D
These
are
all
brand
new
files
hitting
this
repo
for
the
first
time
and
then
so
I'll
merge
the
api
and
the
js
with
their
history
and
then
move
them
around
into
this
structure.
D
So
this
structure
effectively
is
the
pkgs
is
the
packages
and
inside
there
I've
got
api,
which
is
the
existing
api
repo
with
all
that
source
code.
I
think
it
was
down
the
bottom
just
before
yeah.
D
So
effectively
in
here,
you've
got
like
the
the
api.
This
effectively
is
the
api
repo,
all
its
source
and
its
content,
and
if
you
collapse
that
one
you'll
see
under
that,
I've
then
got
core
context
so,
rather
than
the
names
being
expanded
so
like
in
exporters,
you'll
actually
see
all
the
exporters
with
their
open
telemetry
dash
exporter
ripped
off
the
front
as
the
folder
name
just
to
try
and
keep
it
a
bit
shorter.
B
D
So
if
you
go
to
the
root
there's
a
rush.json
which
lists
all
the
packages
that
are
built
as
part
of
this
okay
and
then
effectively,
what
I've
done
is
every
package
that's
being
built,
is
also
generating
a
bundle
both
minified
and
unminified,
which
is
for
the
browser
so
and
it's
creating
it
in,
like
common
js
amd
umd
users
roll
up
to
do
it
so
that
I
can
then
eventually
create
size
tests.
D
So
we
can
actually
validate
the
the
size
of
these
things
or
going
up
or
down
or
don't
exceed
some
limit,
and
an
extra
thought
that
I
had
is
once
we
get
this
going,
we
probably
should
be
able
to
host
that
into
a
release
folder
and
then
potentially,
we
could
get
the.
D
Your
example
martin
to
actually
load
the
sdk
from
the
published
bundle
directly
out
of
github.
Okay
as
a
simple
example,
and
we
can
see
what
all
the
timings
are
and
how
it's
gonna
work
rather
than
having
to
go
through
the
publish
and
host
it
on
the
cdn.
We
can,
in
theory,
should
be
able
to
pull
it
straight
out
of
github.
B
So
that
this
looks
like
drastically
different
from
the
js
sdk,
do
you
think
there's
any
chance
that
withdrawal
it
could
get
merged
back.
D
We'll
see
so
I
I
did
this
because
of
all
the
long
names
and
I
I
developed
on
windows,
so
the
long
names
are
always
painful
but
yeah.
I
don't
know
we'll
see
how
we
go.
The
whole
point
of
the
sandbox
is
to
try
some
stuff
and
see
what
happens.
B
D
Because
I
wanted
to
merge
the
api
and
the
sdk
so
that
effectively
we
can
make
minification
changes
to
the
api
and
then
build
it
locally,
rather
than
having
to
go
through
a
published
step.
That's
why
the
api
is
here.
Okay-
and
this
is
just
a
logical
grouping
in
terms
of
the
experimental
packages-
I'm
not
quite
sure
whether
we
should
put
them
into
this.
Just
the
package
folder,
because
this
entire
sandbox
is
experimental
or
whether
we
also
replicate
that
sort
of
structure
and
have
a
separate
experimental
package
because
rush
can
handle
multiple
products.
D
It's
fine,
it's
just,
and
so
not
everything
there
is
built
because
effectively,
I
copied
over
the
the
entire
packages
from.
B
D
I
guess
until
I
get
the
initial
one
in
there
actually,
if
you
look
at
the
read
me
in
the
root
I've,
I've
got
some
proposals
for
some
branches
there,
where
I'm
calling
minification
and
release.
We
probably
want
to
figure
out,
because
the
the
whole
thing
I'm
thinking
of
is
main
will
be
used
to
synchronize
between
the
main
api
and
js
replace
and
then
for
any
work.
We
want
to
trial.
We
can
create
separate
branches.
So
at
the
moment
I'm
proposing
minification
and
release
because
minification
is
my
my
my
focus
for
this.
D
D
But
if
there's
other
work
we
want
to
trial
in
the
sandbox,
then
perfectly
the
idea
would
be:
we
create
a
branch
and
go
and
play
with
it,
and
then
we
can
keep
merging
that
branch
back
with
the
main
branch
which
is
gonna.
I'm
gonna
try
and
have
an
automated
step
that
keeps
sucking
in
changes
from
the
from
the
master
repos.
D
So
that's
why
all
the
automation
scripts
so
and
why
the
branching
structure,
I
don't
wanna,
try
and
double
fix
in
both
repo.
So
I
don't
want
to
make
that
as
much
as
possible.
D
D
I
think
it's
only
like
three
files-
it's
not
too
big,
but
they
do
need
to
be
pushed
back
up
because
the
whole
goal
of
this
is:
do
we
end
up
creating
a
separate
repo
for
web?
Only
or
can
we
continue
with
the
current
approach.
D
And
we
want
to
be
binary
binary
in
javascript
compatible
so
that
if
someone
can
go
and
create
some
instrumentation
using
the
standard
stuff
and
then
if
we
create
a
separate
web
one,
it
can
just
load
it,
because
it's
all
dynamic
and
it's
got
the
same
properties.
B
Okay,
let's
sounds
great.
D
Yeah
it's
my
original
goal
was
to
have
the
pr
out.
Last
week
I
managed
to
publish
it
yesterday
and
then
hit
these.
You
know
running
all
the
tests
in
github,
especially
the
linting,
was
the
first
one
that
got
me.
I
thought
I
was
running
that
locally,
but
I
had
a
bug
and
then
at
637
files.
It's
not
going
to
be
reviewable.
So
therefore
getting
emerged
to
be
painful.
So
that's
that's.
This
week's
focus
is.
D
Yeah,
and
also
at
the
very
top
of
the
of
this
readme
there's
all
the
stuff
that
I
stated
originally
about
the
sandbox.
It's
like
this
is
not
production.
There
will
be
no
production,
support
and
pushing
people
at
the
main
ones.
So.
B
Okay,
any
other
last
minute,
questions
or
topics.
B
If
not,
then
we
can.
We
can
end
soon.
D
B
I
don't
know
he's
traveling
this
week,
I
think
he's
in
india
and
he
said
that
he
was
gonna,
try
to
attend
this
meeting,
but
he
wasn't
sure.
So
I
don't
know
if
that
applies
to
logs
as
well.
D
Okay,
I
I
might
join
and
if
there's
nothing
that
I
can
recommend
yeah.