►
From YouTube: 2022-04-27 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).
B
C
Or
we
can
get
started
that
can
join
all
right,
so
bogdan
thanks
for
joining,
so
we,
some
of
us,
have
been
working
on
on
on
this
client-side
telemetry
stuff
for
a
few
months
now
I
think,
most
of
the
stuff,
the
good
only
the
sessions
part.
I
think
there
is
a
confusion
mostly
because
I
also
want
to
give
you
some
background
sessions
is
something
that
has
been
computed
in
the
back
ends
in
our
products.
C
So
far
as
in
the
session,
id
was
not
being
sent
from
the
clients
and
session
is
basically
a
timeline
of
user
activity.
So
you
want
to
see
when
a
user
visits
a
website
which
series
of
you
know
pages
that
they
navigate
to
and
then
you
know,
derive
some
user
behavior
right
and
let's
say
you
know
there
is
some
error
that
occurs
in
a
mobile
app.
They
want
to
know.
What
exactly
are
the
you
know,
series
of
steps
that
they
did?
C
You
know
before
the
app
crashed
before
they
have
given
error,
so
that
is
one
key
property.
You
know
that
sessions
give
us
that
you
know
they
tell
us
the
you
know:
sequence
of
screens,
you
navigated.
C
We
also
want
to
know
the
number
of
users
that
are
active
right
now,
right,
active
users
or
active
sessions,
and
while
you
know
users
might
be,
you
know
logged
in
or
they
might
have
a
tab
open.
It's
common
that
you
know,
people
you
know,
keep
the
tabs
open
and
they
move
on
to
other
tabs
right.
So
we
don't
want
to
consider
them
as
active
beyond
a
certain
idle
time.
C
C
That's
a
little
tricky
to
answer.
Who
defines
that
that's
the
behavior,
you
know
we
have
been
having
in
our
current
products.
C
I'm
talking
about
cisco,
app
dynamics,
product,
okay
dynamics,
okay,
okay,
okay,
okay,
that's
the
current
behavior
yeah.
C
The
back
end
today
it's
on
the
back
end
as
you're
receiving
the
you
know,
messages
from
the
client.
If
there
is
a
pause
of
more
than
let's
say
five
or
ten
minutes,
then,
when
the
next
series
of
events
come,
you
tap
them
with
a
new
session
id
yeah.
So.
B
B
B
So
so
can
we
not
introduce
a
new
concept
of
session
and
maybe
reuse
one
of
the
existing
concepts
that
we
have.
Maybe
we
cannot,
but
I
want
to
at
least
brainstorm
that
and
make
sure
that
we
are
not
just
saying.
Oh
no,
because
this
is
on
the
client
side.
This
is
different,
sure
it.
It
has
a
different
name,
but
if
it's
very
similar
with
some
something
else,
maybe
we
can
change
the
name
and
make
that
generic
or
something
to
not
have
to
deal
with
too
many
concepts.
E
B
Yeah
to
answer
these
things
kind
of
this
is
my
position,
because
so
far
what
I've
seen
was.
We
have
this
session,
which
is
very
important
in
client
side,
which
I
understand
I
understand,
because
I've
seen
this
in
google
analytics
and
couple
of
other
products,
I've
seen
the
notion
of
a
session.
You
are
not
the
first
one
to
have
it
enough
dynamics
or
others.
B
Now.
Is
that
generic
enough
that
and
is
defined
this
way
that
you
describe
for
everyone?
I
don't
know
somebody
has
to
do
some
analysis
on
this.
Second,
is:
is
this
concept
similar
the
reason?
One
of
the
things
that
I
asked
in
the
document
that
ted
shared
with
me
was
like
it's
a
time
span,
so
it
looks
somehow.
C
D
B
Series
of
events
so
timeline
of
events
or
whatever,
where
where
essentially
you
come
up
with
some
definitions
of
when
you
you
draw
a
line
like
or
whenever
you
split
this
into
different
things,
and
one
of
the
definition
is:
if
person
goes
idle,
the
other
one
is
if
the
person
I
don't
know
what
it
does.
Maybe.
B
Whatever
other
things
can
happen,
different
actions
happen.
Then
then
you
split
this.
This
also
looks
for
me
like
a
trace
in
somehow,
like
you
have
a
span
that
is
this,
so
I'm
trying
to
to
make
sure
we
are.
We
are
defining
the
right
thing.
The
other
association
that
I
had
in
mind
is,
for
example,
is
very
similar
also
with
in
a
way
with
a
function
like
lambda.
B
B
C
Yeah
so
yeah.
I
think
these
are
all
many
of
these
questions.
If
not
all
you
know,
we
have
discussed
in
the
past,
so
I'll
make
an
attempt
and
others
can
chip
in
too.
I
think
your
your
first
question
was
whether
the
product
requirements
are
are
common
across
all
products.
I
I
don't
know
that.
I
I
think
I
would
request
you
know
each
one
to
comment
on
that.
C
Can
can
somebody
quickly
or
each
one
of
you
quickly?
You
know
clarify
whether
you
want
a
new
session
after
a
idle
timeout
after
inactivity.
F
F
It
will
you
know,
change
others
when
the
user
opens
up
effectively
a
logical
tab
in
in
the
window
when
they
close
that
tab.
It
goes
away.
So
it
really
isn't
it's
a
the
session.
Id
really
is
a
grouping
id
and
it
depends
on
the
team.
That's
using
it
in
terms
of
what
the
relevant
time
span
is.
A
Yeah
we
currently,
we
currently
generate
a
session
id
for
all
all
tabs
and
we
don't
have
you
don't
have
an
expiration.
So
it's
based
on
the
user
closing
the
browser
which
is
not
the
ideal
behavior.
I
think
we
should
have
some
kind
of
idealist,
some
kind
of
timeout
for
idle,
but
that's
what
we
have
right
now:
okay,.
A
C
Mentioned
that
you
you
want,
like
a
you
know,
going
forward
as
a
new
feature.
You
want
the
sessions
to
expire
on
on
inactivity.
G
Yeah,
so
we
we
have
a
wide
variety
of
cases.
Like
microsoft
does
we
also
have
the
case
where
one
might
not
have
a
session,
in
which
case
we
just
want
to
send
events
with
possibly
some
sort
of
user
identifier
as
well,
which
is
more
like
what
the
google
google
analytics
for
behavior
is,
but
we're
still
primarily
session
based.
G
It
can
be
both
so
right
now
we
end
on
based
on
a
timeout,
but
you
know
we'll
also
have
cases
where
it's
tied
to
login
log
out
of
the
user.
H
For
microsoft
and
I've
spoke
spoke
about
other
use
cases
and
stuff,
but
I'd
like
to
add
a
couple
of
other
things
that
I've
noticed.
You
know
the
session
usually
is
login
logout,
like
quinn,
was
saying.
So
that's
like
the
uber
thing
the
moment
somebody
logs
out
the
session
ends
no
matter
what
it
is
and
stuff
and
another
thing
that
I've
seen
is
a
session
being
both
done
in
client
side
as
well
as
back
end.
Also,
if
there's
a
long
running
session,
the
backend
processing
system
sometimes
will
curb
a
session.
H
You
know
you
cannot
have
a
session
more
than
a
day
or
something
is
a
notion
that
they
might
have
in
the
back
end.
I've
seen
such
implementations.
I
don't
think
that's
going
to
be
helpful,
but
it
will
be
good
to
have
in
the
context.
I
think
so.
There's
yeah
those
are
the
two
things
I
would
like
to
add
to
what
ned
said
from
our
side.
H
E
C
Okay
and
after
that,
if
the
user
resumes,
you
would
consider
it
a
new
session.
Yes,
so
book
then
yeah,
it
seems
to
be
a
common
requirement
to
generate
a
new
session
after
inactivity,
so
we
do
have
multiple
strategies.
In
fact,
there
is
another
design
document
we
have
where
we
also
mentioned
that
implementing
this
inactivity
is
is
not
straightforward,
you
know
we
want
it
not
to
be
the
default.
C
The
default
is
still
where
a
session
continues
unchanged,
but
then
a
a
customer,
a
developer,
could
could
always
you
know,
configure
an
inactivity-based
one
once
as
and
when
you
know
we
made
that
implementation
stable
and
in
a
mobile.
Also,
I
think
it's
a
it's
a
similar
behavior,
where
you
keep
using
the
mobile
in
mobile.
It's
actually
more
tricky.
It's
it's
one
instance
in
in
browser.
You
have
multiple
tabs
multiple
instances
of
the
same
user,
but
in
mobile
app.
It's
only
one
app.
C
You
use
it
for
some
time.
Push
it
to
the
background.
Come
back
a
few
hours
later.
You
want
to,
you,
know,
use
it
again,
so
that
definitely
is
not
the
same
session.
That's
a
different
session
and
in
each
session
the
pattern
of
navigation
could
be.
You
know,
different
and,
and
that's
where
and
and
to
test
point
as
to
why
it's
tied
to
a
resource
today,
I
I
think
we
can
now
go
to
your
second
point.
You
know:
have
we
looked
at
existing?
C
Our
first
proposal
for
implementing
sessions
was
actually
a
span
processor
and
a
log
processor
that
you
know
picks
up
the
sp
session
context
session
context.
The
session
id
we
said,
we'll
keep
it
in
a
session
context
in
the
context
similar
to
the
trace
concept
context,
and
then
there
will
be
a
span,
processor
log
processor
that
will
attach
that
session.
Context
in
you
know
to
every
signal:
that's
emitted
that
will
work.
C
The
problem
that
was
raised
was
there
is
already
you
know.
Quite
a
bit
of
you
know,
duplication
and
the
pillowed
payload
concerns
the
size
constraints
because
of
which
it
is
strongly
recommended
to.
You
know
not
duplicate
things
and
maybe
in
the
back
end
it's
okay,
but
on
the
client
side,
browser
side
and
the
mobile
side,
it's
strongly
recommended
to
you
know
avoid
duplications
as
much
as
possible.
So
we
wanted
to
avoid
the
same
attribute
in
every
span
every
event
every
log.
C
C
But
then
you
know
we
also
wanted
that
property
to
change
that
attribute
to
change
once
in
a
while,
but
we
did
consider
trace.
The
problem
here
with
trace
was
that
a
session
typically
are
very
long
running.
Like
you
know,
multiple
minutes
right,
you
know
traces
more
suitable
for,
like
you
know,
one
network
call
right
and
you
can
you
can
model
this
as
trace,
but
then
there
are
corner
cases
where
you
don't
know
when
this
session
ends
a
lot
of
times.
C
You
know
your
browser,
you
know
you
just
close
the
browser,
you,
your
mobile,
app
crashes,
so
we
still
need
some
back-end
processing
to
say
that
hey
this
session
has
ended.
So
we
we
started.
You
know
receiving
events
with
the
new
session
id.
So
therefore,
let's
close
the
previous
session,
so
the
session.
C
Is
not
deterministic
all
the
time.
C
Yeah,
no
I'm
just
saying
that
a
trace,
you
know
typically
goes
across
multiple
services
right
here.
Everything
is
in
one
service.
Everything
is
in
in
one
process.
It's
it's!
It's
an
orthogonal
dimension.
It's
a
you
know
trace
goes
from
one
service
to
another,
whereas
you
know
a
session
stays
in
one
service,
but
goes
on
the
time
dimension.
B
Because
you
you,
for
example,
one
of
the
reason
why
you
want
to
do
the
session
id
is
because
you
want
to
correlate
back-end
operations
between
each
other,
because
they
are
part
of
different
traces,
but
they
they
were
generated
by
the
same
in
the
same
session.
So
that's
what
you
try
to
model
correct.
So
you
you
try
to
model
that
back-end
operations
like
let's
assume
in
case
of.
F
It's
more
a
case
of
it's
a
series
of
different
events
that
happen
on
the
client
so-
and
you
may
not
have
you
know
like
in
terms
of
having
a
span
and
having
a
bunch
of
events
and
then
ending
the
span
that
that
doesn't
work,
because
you
could
have
a
completely
different
series
of
sequences
like
when
a
browser
loads
effectively.
You
you'll
send
a
page
view
event
that
is
effectively
a
span
of
zero
length
to
say.
F
Oh
a
page
view
of
that
happened,
it
may
or
may
not
contain
some
performance
data,
as
the
user
is
clicking
around
on
a
page.
You
may
be
sending
events
saying:
oh
the
user,
clicked
on
this
button,
or
they
they
hovered
over
this
section
of
the
page,
then
the
only
way
they're
linked
together
is
is,
via
the
session
id
there's
no
overriding
spam
to
say
these
things
are
all
grouped
together.
The
the
session
really
is
looking
at
groups
together.
F
B
B
Okay,
good
now,
if
so,
the
way
how
I
can
see
this
as
making
a
case
to
be
a
session
is
a
resource
is
if
we
say
that,
essentially,
every
session
represents
a
new.
B
Source
of
data,
okay,
like
if
a
session
is
identified,
the
session
id
identifies
as
source
of
data.
Now
the
problem
is:
how
do
we,
which
I'm
fine
like.
B
B
I
I
can
see
that
now
in
case
of
the
timeout
okay
forget
about
that
timeout.
Now
this
one
for
me,
it's
very
similar
with
function
with
cloud
functions,
id
or
or
even
the
service
instance
id
that
we
have
in
inside
our
resources,
which
is
an
instance
of
this
code
running
for
a
period
of
time.
C
B
B
C
There's
one
difference:
yeah
there
is
one
difference,
I
think
the
same
instance
you
know
can
have
you
know,
ideal
connectivity
and
the
same
instance
can
resume
activity
after
a
timeout.
I
think
that.
B
B
C
C
C
B
H
So
going
back
to
the
functions,
maybe
if
we
thought
about
another
use
case
or
scenario
it
might
help,
you
know
understand
why
it's
not
going
to
work.
I
think
the
scenario
that
I
have
in
mind,
I
believe,
is
going
to
contradict
what
you're
saying
bogdan
is
same
mobile
device
or
browser.
H
You
know
I
have
a
browser.
I
log
in
a
new
session
is
started
and
then
I
log
off
I
go
away.
Santosh
comes
and
logs
in
on
the
same
machine.
Everything
else
is
going
to
be
the
same,
but
it's
got
to
be
a
new
session
or
you
know
I
think
that
would
not
fit
if
we
used.
That
example
of
you
know,
lambda
right,
lambda,
it
it
starts
up.
Spins
up
serves
the
request
goes
away.
Second
time,
it
starts
up.
It's
exactly
the
same
identifier
and
you
know
everything.
H
B
So
I
think
I
think
yes,
but
I
think
there
are
two
ideas
in
the
lambda
part.
There
is
a
there
is
the
idea
of
the
function
or
the
lambda
that
is
executed,
which
is
kind
of
an
md5
of
the
code.
So,
every
time
when,
when
I
update
the
code,
I
get
a
new
version
that
does
the
version,
and
then
there
is
the
instance
which
is
generated
every
time
when
the
lambda
is
triggered.
B
C
So
let
me
ask
you
know
in
a
different
way,
so
let
me
turn
this
problem
into
the
you
know.
Problem
of
you
know,
duplication
and
deduplication
of
the
spanner
triggers
so.
B
You
know
so
wait
wait
before
doing
that,
because
we
are
on
the
good
path
of
I'm
convinced
that
can
be
a
resource,
but
now
because
because
of
similarities
with
this
and
also
the
difference,
we
cannot
reuse
the
instance
id,
for
example,
service
instance
id
we
can
argument.
We
can
argue
that,
but
it's
very
similar
in
in
some
ways
it's
living
for
a
period
of
time.
In
the
timeline,
it's
only
unique.
It's
uniquely
identified
this
part
is
making
sense,
but
now
how
do
we?
B
C
H
Becomes
multiple
sessions
that
would
be
a
problem
right
simultaneously
running.
H
Be
in
different
tabs
anyway
right.
I
think
that
is
not
a
problem.
The
use
case
that
net
can
probably
chime
in
the
use
case
that
we
have
for
teams,
and
you
know
perhaps
other
oh
yeah
yeah.
He
did
tell
us
about
that.
C
Yeah,
it's
the
same
right.
Let's
say
you
have
multiple
pieces
on
the
same
app.
You
know
you
know
requiring
you
know
different
sessions,
some
of.
C
Whichever
need
the
sessions
to
be
reset
or
inactivity,
what
buktan
is
saying
is
at
that
point.
Instead
of
modifying
the
existing
resource,
object,
he's
saying:
throw
away
the
tracer
throw
away
the
tracer
provider,
get
a
new
tracer
provider,
attach
a
new
resource
to
it
with
the
new
session
id
and
then
use
that
yes,.
F
B
The
reason
why
I'm
saying
that,
let
me
let
me
explain
what
I'm
saying
why
I'm
seeing
that,
let's,
let's
get
on
synchronization
problems,
for
example.
B
Let's
assume
I
had
an
event,
let's
assume
I'm
deciding
right
now
to
swap
the
the
resource
and
some
spam
started
with
this
provider
and
and
then
I
have
to
create
a
child
span
and
now
I'm
creating
a
child
span
in
the
that
child
span,
because
whatever
I
want
to
do
treating
inside
my
app
correct-
and
I
want
to
have
a
couple
of
children
spend
if,
if
the
resource
changes
at
any
moment,
because
that's
the
assumption
that,
with
the
proposed
resource
provider,
I
may
end
up
with
spans
in
different
resources.
F
Yeah,
I
I
guess
as
part
of
the
resource
provider,
it
was
depending
on
the
implementation
of
the
resource
provider,
how
it
would
handle
that.
So
there
are,
there
are
cases
and
there
are
hacks
that
exist
today,
which
I
I
like.
The
javascript
sdk
has
to
start
asynchronously,
because
resources
can't
be
changed
and
we
have
to
wait
until
the
resource
ids
are
available
before
we
can
even
start
sending
and
creating
spans.
F
Having
the
resource
provider
potentially
do
the
fetching
of
resources,
asynchronously
and
therefore
hold
up
you
know,
so
you
can
start
the
span.
You
can.
You
can
start
firing
events
and
at
the
point
of
ending
the
span
or
you're
about
to
export,
depending
on
the
implementation
of
the
resource
provider,
either
a
graduate
at
the
start
or
if
it's
an
asynchronous
resource
provider,
it
could
effectively
give
you
those
at
the
end
but
yeah
you're
right.
It's.
There
is
a
problem.
If
the,
if
you
use
a
resource
provider
that
changes
the
ids
on
the
fly,
it's
a
problem.
F
B
Yeah
but
independent
of
the
implementation,
you
can
implement
the
async
and
indeed
do
what
you
propose,
which
is
grab
it
at
the
end.
To
give
some
time.
For
that
thing
to
to
finish
and
stuff
like
that,
which
is
great,
I'm
not
suggesting
to
not
do
that.
That's
an
implementation
detail!
What
I'm
suggesting
not
to
do
is
have
the
resource
changing
ids
without
changing
the
provider,
because
that
means
events
that
you
may
expect
to
happen
in
the
same
resource
may
not
happen
in
the
same
resource.
F
But
if
we
say
we're
going
to
create
a
new
trace
provider,
there
is
no
chance
of
asynchronous
because
you're
effectively,
you
start
a
trace
and
you
can't
delay
fetch
because
it's
going
to
be
in
the
wrong
one.
So
one
good
example
is
in
a
browser
there's
especially
on
all
the
new
chrome
stuff,
to
identify
the
the
operating
system
platform.
F
It's
an
asynchronous
call
like
you.
Can
you
can
craft
the
user
agent
synchronously,
but
that's
now
frozen.
So
if
you
go
to
a
windows,
11
machine
and
look
at
the
user
agent,
it
looks
like
it's
a
it's
running
on
windows
10.,
so
you
have
to
use
an
asynchronous
function
to
to
get
the
value,
but
in
the
meantime
you
may
have
started.
You
know
if
I
start
firing
your
event
to
saying.
Okay,
my
page
view
is
here.
F
You
then
go
and
fetch
the
id
it's
okay.
This
is
a
windows,
11
box.
You
want
to
tag
the
page
view
event
that
was
windows,
11,
not
windows,
10.,
but
you've
already
fired
the
event.
So,
in
fact,
if
you've
got
an
asynchronous
resource
provider,
it
can
asynchronously
update
that
at
the
point
of
export-
or
you
know.
B
Once
you
decorate
it
first
time
you
shouldn't
change,
that's
that's.
What
I'm
trying
to
achieve
events
recorded
to
the
same
provider
should
be
with
the
same
resource.
No
matter
when
you
resolve
the
results,
you
may
resolve
the
export
time
whatever
when
they
leave
the
process,
they
should
be
associated
with
the
same
resource.
C
Actually,
I
think
we
discussed
this
in
the
past
and
what
we
missed
is
that
you're
talking
about
internal
spans
right,
we
thought
that
once
a
span
is
created,
you
know
it
is
under
the
tracer
hands
over
the
resource
to
the
spam.
And
then
you
know
we
are
good.
You
know
we
can
change
the
you
know
resource
in
the
in
the
tracer
now,
but
then
we
didn't
think
of
you
know
another
span
created
in
the
same
process
as
an
internal
span.
B
So
so
another
thing
is
think
about
events,
even
events,
you
may
be
in
the
middle
of
executing
a
function.
Okay-
and
you
record
an
event
here
and
then
record
here
and
if
b
in
between
the
two
events,
the
resource
decides
to
change,
for
whatever
reasons
a
timeout
expires
are
those
not
correlated
anymore.
F
That
one's
very
hard,
because
it
depends,
I
had
a
thought
and
then
it
just
disappeared,
just
started
talking
hate
that.
F
No
I've
lost
the
train.
I
thought
that
I
was
thinking
okay,
I'll,
try
and
remember.
B
I
think
we
all
agree
that
resource
makes
sense,
because
it's
identifying
a
source
of
data,
but
now
now
is
how
do
we
delimitate
this
resource
or
or
source
of
data,
because
changing
it
on
the
fly
comes
with
these
problems
like
with
problems
like
things
that
logically
should
be
together
like
two
log
statements
in
the
same
function
may
end
up
in
different
resources:
yeah.
H
I
I
think,
that's
a
great
point
on
paper.
It
might
sound
like
a
resource,
can
change
on
the
fly
in
between
a
function
in
execution
or
something,
but
really
I
cannot.
I
like
my
brain
just
really
quick.
I
don't
think
there
is
a
practical
use
case
that
would
cause
that
right
session,
ending,
usually
is
inactivity,
is
going
to
cause
session
ending
but
you're
actively
working
on
something
the
the
it's,
the
the
inactive
timer,
probably
wouldn't
kick
in
when
stuff's
working.
H
So
I
cannot
think
of
a
scenario
where
you
started
a
method
methods
executing
in
between
session
underneath
just
stopping
or
something
seems
a
little
bit
of
a
corner
case.
I
you
know
perhaps
it
might
exist,
but
I
don't
think
it's
it's
practical.
I
don't
know
others
think
about
scenarios
where
it
might
happen.
The
other
things
are
clear,
markers
right.
Somebody
logging
out,
if
somebody
logs
out
the
function
execution
has
to
finish
so
so
that's
that
that
basically
just
eliminates
that
other
things
might
be
something
from
under
that
function,
execution
just
being
pulled
out.
F
The
the
idea
of
the
resource
provider
was
at
the
point
of
the
span
being
created
it
would
we
would
actually
tag
the
span
with
the
resource
provider.
So
if
we,
if
the,
if
the
resources
changed,
we
would
actually
change
the
resource
provider
which
effectively
is
the
equivalent
of
what
you're
saying
by
changing
the
trace
provider,
but
it's
more
lightweight
and
that
it's
just
the
resources,
not
everything
that
the
trace
provider
or
metrics
provider
or
log
provider
implements
so
and
that's
the
case
as
a
resource
provider.
B
B
Does
not
solving
the
problem
with
the
function
like
if
I
have
two
log
statements
in
the
same
function,
I
mean
still
with
your
proposal.
I
still
can
end
up
with
those
two
log
statements
in
different
sessions.
C
But
you
don't
know
yeah.
So
let
me
also
answer
that,
so
I
I
think
the
assumption
is
that
you
know
when
we're
talking
about
idleness
inactivity.
You
know
there
might
be.
You
know,
at
least
in
the
mobile
app
it's
unlikely,
because
the
mobile
app
is,
you
know
they
don't
run
in
the
background.
C
It's
very
rare,
so
browse
it's
only
applicable
to
the
browser
apps.
So
you
know
you
have
a
tab
open
sitting
there
for
a
long
time,
and
you
don't
know
you
know
it
might
be
doing
some
background.
You
know
ajax
calls.
C
So
it's
okay
to
you
know,
consider
them
those
events.
You
know
when
this
when
let's
say
you
go
open
an
old
tab
and
then
resume
activity.
C
B
C
So
so,
actually,
that's
why
I
think
I
I
should
ask
you
about
what
is
the
alternate?
So
so
there
is
a
slightly
you
know,
another
problem.
You
know
we
want
to
get
your
feedback,
so
so
we
have,
as
a
user
is
on
a
you
know,
page
one.
You
know
there
are
a
bunch
of
events.
You
know
that
happen.
C
So
all
the
events
will
have
you
know
one
attribute
representing
which
page
you
are
on,
except
the
current
page
url
and
then,
after
a
couple
minutes
when
he
goes
to
another
page,
that
page
url,
you
know,
will
change,
but
at
least
these
hundred
events
that
came
out
you
know
on
this
page.
They
all
have
this
page
url
attribute
what
is
the
way
to
de-duplicate
this?
You
know
what
is
the
way
to
that's.
That's
simple,.
C
Yes,
no,
but
then
the
instrumentation
scope
seems
like
you
know
you
should
take
it
one
level
further
up.
Why
even
repeat
at
the
scope
level,
because.
E
It's
also
confusing
because
it's
possible.
B
F
Compression
on
the
browser
has
three
issues:
one
is
the
payload
to
actually
create
the
code,
so
you
have
to
get
the
code
to
do
the
compression
in
javascript.
The
the
second
one
is
the
execution
time
to
actually
compress
that
data.
F
It
all
happens
on
the
ui
thread,
so
it
effectively
blocks
the
user
from
doing
anything,
and
it
can
take.
You
know,
depending
on
the
size
of
the
payload,
between
milliseconds
and
hundreds
of
milliseconds,
at
which
point
the
browser
is
unusable
and
the
third
one
is
when
you
actually
send
the
payload
out.
You
have
to
give
it
a
header
to
say
that
the
content
has
been
gzipped
and
that
will
cause
an
options
call
so
effectively.
B
C
Yeah,
so
that
is
where
I'm
saying
that
the
the
instrumentation
scope
attributes
that
tigran
is
introducing.
It
feels
like
a
major
requirement.
There
is,
to
you,
know,
solve
the
dwp
solve
the
duplication
problem,
so
you
know
why
not
take
it
one
level
up
and
have
something
you
know
on
top
of
instrumentation
scopes.
C
C
Because,
essentially,
because
multiple
spans
coming
out
from
the
same
instance
in
the
time
dimension
at
different
times,
you
know
they
have
the
same
attributes.
C
It's
not
just
that
right.
It's
also,
you
know
confusion
in
the
long
run.
You
know
what
does
this
scope?
It's
also
confusion
in
the
long
run
for
for
the
other
people
who
are
not
here,
so
it's
so.
B
C
F
F
C
I
think
the
problem
is,
you
know
there
is
you
you
use
the
word
headers
right.
I
think
the
problem
is,
we
have
frozen
the
headers,
you
know
the
resource.
E
C
Making
it
immutable,
you
know
there
is
no
other
place
for
keeping
things.
You
know
for
sending
some
common
headers,
the
headers
that
are
common
to
all
the
events
in
the
payload.
There
is
no,
there
is
no
other
option
there.
F
F
The
same
argument
as
to
why
they're
not
is
the
same
argument
that
we
have
here
in
that
you,
you
have
a
set
of
things
that
an
application
developer
will
want
to
put
in
which
are
common
across
all
the
every
everything
coming
out
of
that
environment,
because
it
represents
the
user
so
like
currently
we're
talking
about
the
the
session
id,
but
there's
also
the
user
id
there's,
also
the
page
url
and
when
you're
in
a
spa
effectively.
F
The
page
url
will
change
even
without
the
instance
changing
so
like
we're
at
three
fields,
and
I
can
probably
keep
thinking
and
come
up
with
a
bunch
of
others
and.
F
F
Yes,
you
you
can,
you
can
have
it
have
a
page,
open
and
then
say
I
want
to
open
this
up
in
a
new
tab
and
you
can
continue
over
there
and
they're
still
considered
the
same
session.
Depending
on
the
application.
I
will
put
that
cabinet
in
some
applications
will
want
it
to
be
different.
Other
applications
won't.
H
I
think
logan's
question
was:
can
we
have
two
sessions
at
the
same
time
right
partner?
One
day
you
can
have
that
session
being
shared
two
sessions
at
the
same
time
was
that
your
question.
F
Yes
in
time,
yes,
you
could,
you
could
have
different
areas
of
the
code
being
recorded
with
different
sessions,
so
we
have
this
today
with
onedrive
so
effectively,
you've
got
the
page
up
and
up
and
playing
they
click
on
a
link.
They
want
to
open
up
a
brand
new
session
for
a
while
you're
watching
a
video,
and
when
that
video
finished
it
goes
away
so
and
they
have
a
specific
session
id
just
for
that
video
play.
J
F
I
think
that
that's,
I
think,
what
what
he
was
defining
was
you
know
having
a
set
of
resource
ids
that
can
change.
B
I
B
C
Actually,
we
can
give
it
some
more
time
because
at
least
when
the
page
changes
the
whole
sdk
initializes.
So
you
know
you
it
will
be
a
new
static
attribute
on
the
instrumentation
scope,
so
it
doesn't
have
to
be
a
runtime
attribute.
C
C
F
You're
always
on
the
same
page
right
in
the
case
of
yes,
but
the
url
will
change
so
the
page
url
will
change
and
then,
depending
on
the
framework
you're
using
it,
will
either
be
the
fragment
stuff
after
the
hash
or
you
can
actually
configure
it.
So
the
entire
url
changes
react
now
has
highest
ability.
B
F
And
that
was
why
they
at
that,
at
the
point
of
recording
the
event
it
was
going
to
be
given
effectively
the
container
I.e
the
resource
provider,
which
effect,
is
what
the
resources
are
today.
So
it
really
is
a
case
of
at
the
point
of
creating
the
event.
The
fact
that
resources
are
immutable
today
is
is
fine
so
that
the
resources
get
stamped
at
that
point,
but
when
we
having
the
resource
provider,
what
you
would
do
is
flip
out
and
change.
F
So
your
your
concept
of
context
is
exactly
what
the
resource
providers
were
going
to
give.
So
I
think
you
could
have
a
chain
of
resource
providers
so
that
when
you
stamp
event
a
because
the
the
url
is
is
fred,
you
then
flip
over
and
say:
okay,
I've
now
got
a
resource
provider,
because
we've
now
got
bob
as
the
the
url.
So
every
event
from
that
point
onwards
is
going
to
be
using
resource
for
provider
b.
F
B
Okay
and
then
and
then
executes
some
now:
okay,
it
got
resource
provider;
okay,
sure.
So
so
you
you
pass
the
resource
provider
with
the
with
the
function
call
with
the
execution
code.
I
F
F
This
is
the
set
of
resources
so
that
when
it
changes,
you
say,
okay
now
use
this
set
of
resources,
which
is
the
provider
which
is
equivalent
of
your
earlier
thing
of
effectively
creating
a
brand
new
trace
provider
and
then
using
the
new
trace
provider.
Let's
say
it's
more
lightweight,
because
you
don't
have
to
take
everything
you
have
to
reconstruct
everything,
especially
if
you've
got
logs
and
traces,
because
you'd
have
to
create
both.
B
Okay,
I
I
don't
think
we
understand
each
other
here,
but
I
will.
I
will
stay
by
my
words
and
say
that
you
need
to
define
what
happens
before
relationship,
because
if
you
change
on
the
fly,
these
no
matter
how
you
do
it,
you'll
have
a
problem
of.
B
In
my
opinion,
I
have
a
function.
I
schedule
something
a
scene
now
somehow
resource
changed
and
the
the
the
events
that
I'm
gonna
record
in
that
sync
work
that
I
scheduled
before
I'm
worried.
That
will
happen
in
the
new
world,
which
probably
should
happen
in
the
world
all
the
world,
because
we're
generated
by
the
I
I
don't
know
how
you
want
to
model
all
of
these
exceptions
and.
J
C
Where
go
ahead
yeah,
you
know,
I
think,
you're
you're
right.
I
think
those
boundary
cases
are
tricky
and
my
response
is
that
you
know.
So.
If
you
look
at
our
the
way
the
sessions
timeline
is
in
the
shown
in
the
ui,
we
hide
all
the
background
activity
there.
Although
the
background
activity
also
has
the
session
ids
we
at
least
in
our
dynamics
product,
we
only
show
what
the
user
performed
like
what
activity.
You
know
what
buttons
you
click,
only
those
we
show.
C
So
those
I
think
you
know
don't
have
a
problem.
You
know
so
much
yeah.
B
But
but
again
I'm
not
what
I'm
trying
to
say
is
if
you
are
changing
randomly
the
resource.
I
think
it's
a
problem.
I
And
also
yeah,
I
I
guess.
F
F
Every
set
of
events
is
associated
generally
with
that
user
and
generally,
especially
in
a
browser.
It's
a
single
threaded
environment.
So
we
don't
have
the
same
problem.
There
is
the
case,
for
example,
in
in
javascript,
you'd
use
the
set
timeout
function
to
schedule,
something
to
occur
later,
so
you
could
say
user
presses
on
button
x.
F
As
part
of
that,
you
scheduled
something
to
come
back
later
and
then
before
that
happens,
they
click
on
button
y,
which
changes
the
page
url
that
that
can
happen.
How
would
you
deal
with
that?
Well,
it
would
depend
on
what
the
function
the
button
x
is
doing.
F
It
may
be
an
event
that
you
don't
care
about
what
the
url
is
and
if
you
do,
you'll,
probably
effectively
capturing
the
fact
at
the
point
of
them
pressing
the
button
that
you're
firing
that
event
or
you're
starting
the
span.
If
it's
an
ajax
call,
which
means
at
the
point
of
starting
with
spain,
you've
already
captured
all
the
resources
so.
C
Also
other
thing
to
remember
is
you
know
that
information
is
not
lost?
It's
it's
still.
You
know
present.
So
when
you're,
seeing
the
you
know
different
session
timelines
in
the
ui,
you
will
see
that
hey.
You
know
the
session
first
session
started
at
9,
00
ended
at
10
and
then
the
next
one
started
at
1005
right
at
10
itself.
So
you
can
see
that
hey.
You
know
this
event
here
was
caused
by
another
event
in
the
previous
session.
So
it's
it's.
C
I
C
I
think
we
will
think
about
this.
I
think
there
are
two
problems
we
discussed
right.
I
think
the
first
one
about
the
session
id
it
fits
in
the
resource,
but
the
resources
cannot
be
modified
and
your
recommendation
is,
to
you
know,
throw
away
the
trace
provider
and
get
a
new
one
and
start
all
over
right
with
respect.
We
will
see
you
know
how
that
can
be
implemented.
C
So
with
respect
to
the
page
url,
I'm
not
100
convinced
keeping
it
at
the
instrumentation
scope
level,
but
but
I
think
that's
a
good
start
for
sure.
C
Maybe
I
think
next
week
I
think
we'll
come
back
with
some
more
concrete
thoughts
on
these,
and
maybe
we
can.
B
B
B
This
is
where
you
do
the
connection
between
the
runtime
environment
and
the
the
code
environment,
and
what
you
are
trying
to
do
is
actually
do
it
through
resource
or
other
things,
and
maybe
that's
not
the
answer.
I'm
not
saying
I
will
think
more
about
this,
but,
let's
probably
have
oh
anyway.
I
have
to
run
to
to
collect
their
meetings.
Sorry
guys.
C
Yeah
yeah
yeah
sure,
but
I
think
he
is
also
talking
about
how
we
can
change
the
attributes
in
a
safe
manner.
F
Which
is
what
the
resource
provider
was
going
to
do
because
effectively
that
you
know
effectively
you
you
flip
out
the
resource
provider
as
as
you
need
to.
There
is
always
the
edge
case,
even
elsewhere,
where,
if
you
don't
fire
the
event
until
sometime
later
well,
yeah,
that's
going
to
be
a
problem.
F
Yeah
and
like
that's
even
possible
today,
like
even
if
the
page
url
is
embedded
in
the
event
that
the
point
of
firing,
the
event
is
when
you
grab
the
page
url
so,
regardless
of
whether
you're
putting
it
in
the
event
or
you're,
getting
it
from
the
resources.
At
the
point
of
firing
an
event
you
grab
a
copy
of
whatever
the
data
is,
so
the
same
problem
exists.
F
F
Anyway,
the
js6
is
on
so
I'm
gonna
jump
over
there.