►
From YouTube: 2022-01-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
A
Oh
yeah,
no
problem,
I
was
thinking
we
could
just
take
a
look
at
it.
B
It's
something
you
want
to
take
a
look.
A
Yeah
go
yeah.
We
can
go
over
just
what
I've,
what
I've
added
so
far,
okay,
but
we
don't
need
to
do
it
right
away.
We
can
go
over
the
you
know,
less
means
notes,
first
and
stuff.
A
I
don't
know
if
vanant's
gonna
be
here
today
since
he's
sick.
E
B
Yeah,
I
added
something
about
that.
I
don't
know
if
that
I,
the
second
point
was
about
that.
I
don't
know:
what's
the
you
can
change
the
title
to
something
that
is
more
meaningful,
yeah.
D
Because
I
didn't
know
how
to
I
think,
bryce
attended
the
meeting
yesterday,
yeah.
D
Finally,
because.
D
Yeah
no
worries,
we
will
talk
about
it,
but
in
addition
to
those
I
have
two
other
topics
that
are
not
being
discussed,
and
I
wanted
to
hear
from
you
you
know,
like
especially
authentication,
is
one
and
configuration
I
I
wanted
to
understand.
You
know
what
you
are
doing
currently
about
those.
B
D
D
D
D
B
Great
yeah,
I
think
we
can
start.
B
Okay,
so
yeah
last
meeting
actions.
Basically
there
were
no
actions
except
the
modern
enough
events
that
we
we
have
a
topic
about
that
so
yeah
from
last
week,
yeah
I
just
yeah
connected.
B
A
bit
late
minute
who's
also,
but
that
he
couldn't
connect
early
as,
but
he
connected
last
and
gave
some
info
that
he
had
changed
his
company
now
and
he
was
expecting
to
use
more
time
on
open,
telemetry,
so
yeah,
but
not
not
much
about
that
and
about
the
events
from
hotel
client.
You
were
in
the
meeting
yesterday
right.
D
Yeah,
so
I
don't
know
how
much
context
you
know
you
had
about
the
topic.
Basically,
there
is
a
debate
going
on
on
which
underlying
data
model
to
use
to
model.
B
D
D
I
think
the
only
case
for
using
a
trace
and
spans
is
to
be
able
to
connect
to
events
saying
you
know
this
event
caused
that
event.
D
D
Not
use
the
trace
signal,
you
know
in
all
cases,
but
I
think
the
argument
is
that
there
are
a
couple
of
arguments
which
is
that
the
log
record
is
too
general.
It's
too
open-ended,
so
it
could.
D
You
know
make
people
you
know,
abuse
it
and,
secondly,
I
think
it's
better
to
use
one
data
model
rather
than
two
different
for
the
same
events.
So
that's
why
I
think
there
is
you
know
possibly
more
alignment
towards
the
zero
duration
spans.
So
yeah,
I
think
no
decision
has
been
taken.
So
if
you
have
any
opinion,
I
think
you
can
put
forward.
A
Yeah,
I'm
not
that
familiar
with
the
log,
the
log
api
I
mean
we
haven't
implemented
it
yet
in
swift,
so
I've
had
really
zero
interactions
with
with
the
you
know
how
it's
supposed
to
work.
A
I
did
talk
to
the
the
like
kind
of
the
head
architect
for
apm
here
at
elastic,
and
he
revealed
to
me
that
we
actually
use
our
proprietary
log
interface
to
do
all
of
tracing
which
is
kind
of
funny.
So
that's
the
the
data
model
that
that
tracing
is
built
off
of
it's
built
off
of
the
log
log
like
data
signal
which
is
kind
of
funny.
But
I
wonder
if,
if
what
needs
to
get
done
is
hotel?
A
Logging
needs
to
be
extended
to
make
it
more
useful
to
events
and
linking
causality,
which
is
seems
to
be
one
of
the
big
sticking
points
for
why
we
don't
don't
like
logs
for
solving
this
events
issue
and
the
sessions
issue
in
open
telemetry.
A
But
yeah
I'd
have
to
look
more
closely
at
logs
and
I
wonder
if
we
need
to
like
kind
of
define
exactly
what
is
missing.
You
know
in
terms
of
what
we
need
for
the
session
stuff
to
make
that
to
make
that
same
and
reasonable.
D
So
sessions
is
a
entirely
new
concept
in
a
not
so
much
discussed.
Yet,
although
there
is
one
of
the
original
proposals
from
aws
on
this
client-side
telemetry,
you
know
they
suggested
sessions
as
a
new
top
level
signal
to
be
introduced
and
session.
You
know
like
a
trace
is,
is
a
container
of
you
know
the
other
events
that
belong
to
that
session
in
in,
for
example,
the
session
id.
D
D
A
new
session
is
created,
a
new
session
has
started
so
it's
just
another
event,
and,
and
the
idea
is
that
all
events
are
typed
or
named
events,
so
you
designate
some
convention
for
you
know
what
is
a
session
event,
a
new
session,
a
session
open
or
a
session
close
events
and
and
and
therefore
it
boils
down
to
you-
know
just
modeling
different
types
of
events
right
and
so
so
that's
why
it
has
not
been
explicitly
discussed
yet
the
discussion
has
has
still.
D
I
also
feel
you
know.
This
topic
is
taking
too
long
that
there
are
several
other
topics
that
you
know
not
getting
attention
but
yeah.
Hopefully
this
is
a
very
important
topic,
so
hopefully
we'll
reach
a
good
consensus
in
the
following
weeks.
B
Okay
from
yeah,
yes
from
my
point
of
view,
if
we
really
have
sessions
at
the
top
level
that
really
makes
sense
but
sessions
they
have
federation
per
se,
I
mean
they
are
not
individual
without
you
know
just
things
that
happen,
I
mean
the
session
kind
of
start
and
can
end,
but
that
has
a
duration
so
modelling
that
as
a
law
or
as
a
one-shot
thing
doesn't
feel
like
well
modeled
I
mean
it's
like
yeah.
The
session
starts,
and
that
happens,
but
also
when
span
starts.
B
So
in
the
same
way
we
are
modelling
spans.
So
we
we
explore
when
they
end,
and
they
have
adoration
is
the
somehow.
It
should
be
the
same
for
sessions,
because
it's
the
the
same
kind
of
behavior
something
starts
and
ends
and
have
childs
that
are
related
to
it.
So
those
other
events
could
be
just
just
in
modelling
in
the
way
of
expanse.
I
mean
that
could
be
like
span
events
that
happen
with
a
parent
that
is
a
session
and
that
could
be
modeled
quite
easily
with
that
model.
B
A
B
A
Yeah
yeah,
that's
the
problem
I
see
with
sessions
is
that
they're
kind
of
open-ended,
depending
on
how
you
define
when
they
end,
and
usually
it's
it's
with
the
activity.
Timeout
right
like
you'll,
say,
like
the
user,
hasn't
done
anything
for
20
minutes
that
last
session,
we
can
say
that
ended
now.
So
that's
the
kind
of
problem
with
fitting
it
into
a
span.
Is
it's
just
too.
B
Yeah
but
but
I
see
a
very
similar
structure
and
and
behavior
and
properties,
except
for
that,
one
that
you
have
an
open-ended
and
and
the
way
we
usually
export
the
spans
currently
are
because
we
we
we
end
them
and
we
send
them
at
the
same
time,.
A
B
If
we
could
somehow
model
that
in
a
way
that
we
export
partial
information
about
it
and
use
events
inside
that
as
the
events,
the
high
level
events,
it
makes
totally
sense
for
me,
yeah
I
mean.
A
B
That's
right,
yeah
or
even
it
could
be
sort.
Somehow,
in
the
background
I
mean
you
create,
send
the
spanish
started
as
a
partial
spam
information
and
just
assign
that
span
as
the
parent
of
all
of
other
expands
automatically.
With
the
same
context,
passing
we
have
response
and.
B
Could
be
just
located
to
the
last
to
the
end
of
the
latest
of
the
spans
whose
the
session
is
apparent
or
something.
D
Quite
well
what
what
no
are
you
are
you
sure
that
the
spec
allows
for
spans
to
be
recent
like
if
you
send
a
span
at
the
time
of
it
start,
and
you
know,
leave
the
end
time
unfilled.
B
Yeah
I
mean
yeah,
that's
not
what
the
spec
says.
I
mean
what
they
say.
A
B
A
Well-
and
you
know
what's
interesting-
is
that
this
sort
of
this
sort
of
issue
pops
up
again
and
again
in
client-side
tracing
like
if
you
want
to
measure
like
a
checkout
process,
you
don't
necessarily
know
when
that's
going
to
end
anyway,
because,
like
let's
say
the
user
just
leaves
the
app
you
know
like
you.
Can
you
can
just
you
can
measure
like
when
a
successful
checkout
happens
because
you're
like
oh,
they
actually
hit
the
checkout
button
and
then
it
processed,
and
it
was
done.
A
But
if
you
know
in
a
bad
path
where
they
like
just
leave
the
app
you
don't
know
when
you
don't
know
when
that
interaction
finished,
because
it
like
times
out
you.
So
you
need
this
concept
of
a
timed
out.
Interaction.
A
B
It's
a
special
kind
of
span
that
is
open-ended
that
is
exported
when
it's
started,
so
you
have
the
trees
id
and
the
span
id
and
you
can
feed
whatever
you
want
yeah
and
when
it's
processed
in
the
backend
it
knows
that
it's
an
open-ended
that
might
or
might
not
have
an
end,
but
that
it
really
started,
and
you
can
maybe
finish
yeah,
for
example.
B
One
thing
I
I
did
in
the
past
is
when
we,
when
you,
as
I
said,
I
am
instrumenting
tests
right
and
sometimes
you
have
network
requesting
a
test
that
you
don't
control.
That
happens
because
it's
in
the
code
and
your
test
just
touches
that
code,
but
you
don't
control
that
that
happens
and
yeah.
You
are
not
expecting
that
network
request
to
end
before
your
test
ends,
and
if
you
don't
end
it
everything
just
get
lost
right.
You
will
never
know
that
happens.
B
So
what
I
did
was
having
a
control
of
all
the
spans
that
didn't
then
and
and
then
myself
and
at
them
a
special
property
that
say
that's
an
unfinished
span
or
something
like
that,
and
it
could
also
be
a
property
of
those
expands
of
those
opening.
The
response,
knowing
that
those
expands
were
never
ended,
so
could
be
a
part
of
the
property,
so
they
were
not
user
ended
but
were
ended
because
of
a
timeout
or
something
happened.
E
B
Bit
of
yeah
with
a
small
change
to
the
spec,
all
this
will
be
solved.
It
looks
I
mean
no.
D
Certainly,
I
think
completely,
I
think,
yeah
yeah,
I
I
agree.
I
think
it
is
you
know,
technically
speaking,
it
is
feasible.
You
know
to
use
either
approaches
it's
just
that
you
know
with
with
the
tracing
data
model.
D
Do
you
see
a
need
for
you
know
representing
sessions
using
let's
say
a
tracing,
ui
or
even
tracing
analytics,
let's
say
because,
because
if
you're
using
a
spans,
you
know
they
end
up
in
a
let's
say,
a
span
store
against
an
even
store
and
typically,
whatever
tools
that
are
built
on
top
of
you
know,
braces
and
spans.
Do
you
see
them
applicable
to
sessions.
D
So
what
I
was
saying
is
that,
on
the
client
side,
you
know
I
feel
either
approaches
whether
they
are
represented
using
the
trace
and
span
signals
or
the
a
separate
logging
signal.
Log
signal
you
know
either
you
know,
is
feasible.
There
might
be,
you
know,
small
differences,
so
the
next
thing
to
look
at
is
on
the
back
end.
D
You
know
what
is
going
to
be
more
convenient
because
are
you
going
to
make
use
of
the
tools
and
the
infrastructure
built
for
the
spans
you
know
for
for
for
for
sessions.
A
Yeah,
that's
that's
interesting
because
in
the
spans
we
have
the
idea
of
a
start
and
end
for
everything
which
is
very
applicable
to
the
session
thing,
and
that's
not
the
case
in
logs
either
way.
Someone
needs
to
look
like
someone
something
you
know.
A
tool
needs
to
look
for
start
and
ends.
So
you
might
have
a
start
event
in
logs
and
then
you
look
for
an
end
event
but
you're.
You
know
you're,
sifting
through
the
logs
and
at
some
point
you
have
to
decide
like.
A
Oh,
if
we
never
find
the
problem
is,
there
might
not
be
an
end
event
because
the
application
may
have
crashed
or
the
user
may
have
shut
it
down,
and
it's
not
sending
data
anymore.
So
it
needs
to
be
able
to
determine
whether
it's
using
a
span
or
a
log.
A
B
It
could,
as
it's
a
different
kind
of
span,
maybe
back-end
tools
could
handle
it
differently,
so
they
can
just
know
that
this
these
events
associated
with
this
span
can
be
more
interesting
or
have
more
visibility.
B
They
are
open-ended
and
you
can
just
paint
you.
You
can
just
just
open
source
jagger
just
to
show
that,
and
you
can
just
improve
over
that
if
you
want
and
show
the
events
there
inside
the
sessions,
so
you
can
list
everything
that
happened
in
the
session
independently
for
the
other
expanse,
I
mean,
I,
I
think
that
that's
how
we
win
having
by
default
tools
that
works
for
you
and
just
iterate
over
there,
for
your
specific
needs.
B
D
Yeah,
it
makes
sense.
Actually
there
is
some
component
in
the
back
end.
That
is,
you
know
that
we
cannot
avoid
where
the
timeouts
can
only
be
detected
on
the
back
end
right,
so
that
not.
D
Well,
let's
say
your
you
know:
app
doesn't
get
a
chance
to
run
again
at
all,
you
just
close
it
and
go
on
yeah.
B
A
B
Yeah
and
that's
a
problem,
you
say
that
is
the
same
problem
for
for
locks.
I
mean
you
need
that
end
event
to
arrive
somehow,
so
you
have
to
build
it
from
from
from
the
same
information,
I
mean
we
need
a
span
and
or
we
need
a
lot
that
says
that
the
session
ended.
B
You
don't
have
that
information
if
something
failed
in
between,
so
you
have
to
build
it
in
the
same
way,
but
maybe
in
the
in
the
in
the
existing
tools,
just
saying
that
a
span
that
has
not
ended
just
you
know,
have
the
foul
value
of
the
maximum
of
their
child
span
or
something
like
that
as
a
you
know,
as
a
fallback
should
be
something
quite
easy
to
implement
or
or
even
just
put
it,
the
with
the
latest
event
associated
with
it
or
having
just
a
duration
of
one
millisecond,
I
mean
there
is
no
problem
there
yeah,
you
already
have
all
the
child's
there.
B
B
E
So
santosh,
how
is
it
done
in
hotel
js
in
the
client-side
web
website
of
the
hotel
js,
because
they
they
would
have
the
same
problem
right?
Because
you
know
browser
sessions
being
long
people?
You
know
just
click
on
something
go
for
a
coffee,
or
you
know,
of
course,
yeah.
It's
the
same
issue
close
the
laptop
those.
D
Kind
of
things
yeah
yeah
yeah.
Absolutely.
I
think
I
still
feel
that
you
know
you
cannot
avoid
having
the
back
end
component
yeah.
A
D
That's
true,
because,
even
if
it
is
for
one
percent
of
the
cases,
you
know
you
still
need
it
and
I
don't
know
I'm
not
a
mobile
app
developer,
but
I
don't
know
I
I
know
that
most
apps,
you
know
they
only
run
in
the
when
they
are
in
the
foreground,
not
necessarily
in
the
background,
unless
they
have
permission.
D
So
as
you
switch
between
apps
as
they
go
to
the
background,
I
think
it's
up
to
the
os
to
determine
when
to
close
them
right.
You
know
at
that
point,
do
they
give
a
call
back
for
applications
to
do
a
cleanup?
Maybe
at
that
point
you
can
send
the
end
span
wherever
possible.
A
Well,
it
I
mean
it's,
it's
variable
right,
like
you
may
or
may
not
get
a
chance.
D
Yeah
yeah
yeah,
I
know
what
I
meant
is
you
know
the
client
side
can
make
the
best
effort
to
send
the
end,
but
I
think
we
cannot
avoid
you
know.
Having
to
you
know,
you
know
having.
C
A
And-
and
it
might
be
best
to
just
assume
the
back
end
is
gonna
handle
it,
because
then
you
get
this
like
weird
like
who,
like
maybe
it'll,
come
from
the
front
end
or
maybe
it'll
come
from
the
client.
Maybe
the
back
end
will
fix
it,
so
it
might
be
just
like
make
the
back
end.
Do
it,
and
then
we
have
one
place
where
it
is
handled
or
like.
I
think
the
problem
is
is
like
how
much
how
much
like
how
much
like
cpu
effort
is
that
gonna
be
on
the
back
end.
A
It
might
be
better
to
be
like
if
we
always
handle
it
on
the
back
end.
It's
like
10
times
more
effort,
whereas
if
we
do
it
like
a
little
bit
of
like
well,
maybe
the
front
end
will
handle
it
and
then,
like
90
of
the
time,
it's
fine
and
then
like
that
one
last
10
percent.
The
back
end
has
to
deal
with
it,
whereas
putting
it
100
on
the
back
end
might
be
an
overload
for
the
back
end.
A
To
kind
of
figure
out
in
terms
of
performance
like
where
the,
where
the
best
like
thing
is,
I
think
I've
seen
in
some
places,
like
maybe
maybe
app
dynamic.
Does
it
this
way
where
they
depend
on
the
front
end
to
determine
the
session,
but
then
all
like
it'll
keep
track
of
what
sessions
are
open
and
then
at
midnight
every
night
you
know
it'll
say
like.
A
Okay,
all
remaining
open
sessions
get
closed
now
and
so
like,
if
they're
a
bunch
of
just
hanging
sessions
that
the
back
end
has
been
monitoring,
then
it'll
shut
them
all
down
and
then
back
date
them
to
whenever
they
last
heard
from
that
session.
Just
assume
that
it
that
it
was
that
it
was
finished.
Yeah.
D
Yeah
so
I
think
in
terms
of
spec
it's
best
to
not
fixed
to
one
approach.
You
know
just
you
know
have
both
yeah
and
and
then
you
know,
I
think
only
our
time
once
we
experiment,
I
think
you
will
know
and
then
it
could
be
a
you
know.
B
Definitely,
the
information
coming
from
the
client
will
be
much
better
as
possible,
but
that's
also
a
problem
that
maybe
that
information
reaches
several
days
later
when
the
user
launches
the
app
again
in
a
mobile
yeah.
And
probably
your
backend
already
has
fixed
all
that
information
and
you
cannot
replace
the
value
of
the
duration
or
that
because
of
course,
and
you
have
everything
already
stored
in
a
non-montable
state
or
something
like
that.
A
B
But
yeah,
I
would
say
that,
if
possible,
the
the
the
client
should
be
able
to
provide
that
information,
but
and
if
it
can
be
updated
great.
But
if
not
just
yeah
use
the
back-end
value
that
can
fix
it
in
the
best
way
possible
and
yeah
and
go
with
that,
because
it
will
be
almost
as
good
as
having
the
real
information.
B
D
So
I
I
plan
to
you
know,
write
this
up.
Hopefully
I'll
have
it
before
our
next
meeting
I'll
I'll
write
this
up
now.
D
Okay,
so
we
can
move
to
the
next,
and
so
this
is
more
of
a
you
know,
question
at
this
point
so
that
we
can
do
some
planning
so
typically
all
the
backend
sdks.
You
know
they
use
the
collector
right,
whereas
the
the
hotel
collector
and
in
the
hotel
collector
they
do
have
an
option
to
configure
authentication
tokens.
They
support
different
plugins
or
extensions.
D
You
know
whatever
it's
called,
you
know
where
you
can
configure
some
authentication,
so
the
collector
is
typically
sitting
in
the
you
know
same
network
where
the
you
know
the
backend
sdks
are
running,
so
the
interaction
between
the
sdks
to
the
character
is,
you
know,
is
without
auth
and
then
from
that
collector
to
you
know,
the
telemetry
back
end
is
authenticated
right.
So
that's
how
I
see
it
modeled
on
the
back
end,
whereas
on
the
client
side
you
know
in
most
cases
you
know
you
know,
people
are
on
the
internet
right.
D
Yeah
exactly,
and
so
there
is
no
collector
so
which
means
that
the
authentication
has
to
be
configured
at
the
source.
So
that's
for
sure
now
what
type
of
authentication
that's
a
very
complex,
complex
topic?
You
know
none
of
them.
You
know
truly
work
because
you
know,
I
think
these
are
end
user
side.
You
know
they
need
to
work
even
before
the
user
logs
into
all
sorts
of
things.
So
it
is
more
of
a
you
know
like
a
feel-good
factor
right.
We
have
some
authentication,
although
they
don't
really.
D
You
know
they're
not
truly
secure
right.
You
know
because
people
can
always
use
that
same
like
at
least
in
the
website.
It's
easy
to
look
at.
You
know
what
is
that
token,
and
then
you
can
always
use
it.
So
it
is
not
in
terms
of
you
know
getting
through
security,
but
it's
more
of
a
an
optional
compliance.
D
You
know
wherever
you
know
you
want
to
use
it.
So
the
fixed
token,
like
you
is
you
know
some
one
time
you
configure
one
time.
That
kind
of
a
token
is
what
I'm
thinking
that
you
allow
the
sdks
to
set.
B
Okay
from
my
side,
I
am
using
own
exporter,
so
I
am
just
using
the
data
exporter
for
my
product,
so
just
authenticating
it
directly
with
the
backend
so
not
using
collector.
B
A
That
yeah,
we
have
a
embedded
collector
in
our
back
end
that
that
captures
that
we
send
the
data
to
over
the
over
the
internet
and
they
and
we
have
a
just
an
authentication
token
that
we
use
so
that
it's
yeah
it's
static.
So
it's
not
very
secure.
If
you
have
like
somebody
who
has
an
unlocked
or
a
what
do,
they
call
it
a
jailbroken
iphone.
You
know
they
can
just
probably
pop
in
there
and
and
find
the
token
in
there
pretty
easily.
B
Yeah
but
but
that's
a
problem
that
you
have
with
any
problem
with
any
program
running
on
the
on
the
user,
I
mean
you
must
have
keys
that
are
really
low
profile,
just
for
sending
data
and
not
much
power
so
yeah.
They
must
that's
a
problem
that
you
will
have
with
with
any
other
project
having
the
keys
in
the
hands
of
the
of
the
user.
B
If
you
are
doing
a
ram
product,
usually
the
user
is
the
developer
of
the
app,
but
that
has
to
put
it
in
the
code,
but
that
will,
at
the
end,
will
be
running
at
the
hands
of
the
final
user.
Who
can
use
wireshark
to
check
your
network
request
and
check
your
ap
api
keys
or
your
keys
in
the
headers,
or
in
the
I
mean
they
have
all
the
power
to
check
that.
So
it's
I,
I
don't
think,
there's
a
solution
for
hiding
that
at
all
just.
B
That
is
only
for
sending
information
to
your
custom
thing
and
hope
they
don't
try
to
deals
to
your
packet.
I
mean
yeah.
D
Yeah,
I
think
I
think,
when
we
write
this
up,
I
think
we
won't
be
claiming
that
this
is
secure.
This
is
just
a
a
compliance
point
to
for
ourselves
to
feel
good
about
that.
There
is
something
the
only
angle
to
security
that,
possibly
you
know
we
could
have
is
you
know,
build
the
ability
to
rotate
it
frequently,
but
that's
again
an
implementation
issue.
You
know
having
the
ability
to
support
multiple
tokens
during
the
transition.
B
Yeah
I
mean
yeah
the
the
thing
there
is
that
that
you
have
to
make
that
run
on
the
mobile
device
of
the
user,
for
example,
so
you
can
rotate
a
key,
but
how
does
the
user
get
that
rotated
key?
I
mean
he
already
needs
to
connect
to
a
server
that
provides
him
that
key.
D
B
Yeah
but
then
you
will
be
the
problem
of
how
the
user
puts
that
into
your
app.
Is
he
going
to
copy
paste
that,
in
in
his
mobile
to
to
affiliate.
D
B
D
Yeah,
no
I'm
saying
that
we
we
don't
claim
this
to
be
secure
at
all.
All
I'm
saying
is
that
you
know
the
we
give
an
option.
D
For
I
mean
there
is
at
least
one
option
for
customers
to
keep
changing
it,
and
you
know
if
we
could
enable
the
back
ends
to
support
multiple
keys
during
the
transition.
Then
you
know
rather
than
keeping
one
key
forever.
You
know
you
keep
changing
it
at
least
once
in
let's
say
one
year.
B
Okay,
yeah
yeah
that
yeah,
that
could
work
I
mean,
but
currently
in
in
our
collector
implementation,
you
can
already
send
your
keys.
Save
I
mean
in
the
in
the
network,
calls
and
configure
your
network.
I
mean
the
grpc
library
supports,
adding
your
keys
to
the
to
the
calls.
So
you
can
even
you
can
just
connect
safely
with
with
keys
whatever
you
implement
in
the
back
end
with
rotating
keys
of
that
stuff.
It's
something
that
the
implementer
has
too
on
their
side.
D
So
far
with
your
open,
telemetry
implementation,
you
you
don't,
have
you
don't
send
any
token
from
the
mobile
app
right.
I
just
wanted
to
check
if
you
are
doing
something
already.
B
B
B
D
To
the
backend
okay,
could
you
point
me
to
you
know
how
it's
done
if
it's
there
in
the
either
in
the
code
or
an
example.
B
B
So
in
that
channel
is
where
you
set
at
creation.
Let
me.
D
B
B
B
B
D
So
it
centers
a
header
and
do
you
do
you
know
what
is
the
name
of
that
header.
C
D
Okay,
so
yeah,
I
think
then
we
could,
you
know,
do
the
same
thing.
Just
you
know
have
a
convention
to
standardize
the
the
name
of
the
header.
So
so
everybody
does
the
same
thing.
D
B
A
Okay,
if
you
go
down
to
the,
if
you
go
down
back
to
the
at
the
bottom,
it
has
the
self.generate
metadata.
It's
just
using
a
bearer
token
authorization
all
the
way
down
at
the
bottom
yeah
there.
It
is
line
160.
A
D
D
Okay,
we
can
go
to
the
next
one,
so
for
the
next
one.
D
During
runtime,
or
even
during
startup,
you
know
there
has
to
be
so
there
is.
There
has
been
a
new
initiative
called
op
amp,
which
is
primarily
for
for
configuring,
the
collector
it
started
off
as
a
general
purpose.
D
Config
exchange
protocol,
mostly
for
the
purpose
of
collectors,
but
they
realized
that
it
is
applicable
even
to
the
sdks
to
configure
the
sdks
okay.
So
it's
still
early
stage,
but
the
way
they
are
thinking
about
it
is,
you
know
they
started
off
with
a
having
a
websocket,
a
separate,
websocket
connection.
D
I
think
they
are
keeping
it
general
so
that
the
telemetry
backend
and
the
management
server
up
to
separate
servers
and
therefore
you
need
to
separate
connections,
so
they
are
recommending
a
separate
websocket
based
connection
to
the
management
server
and
for
cases
such
as
aws,
lambda
serverless.
You
know
where
it's
short-lived
and
and
cases
where
you
only
need
the
config
once
they
are
they're,
also
introducing
an
http
based
api,
where
you
request
for
the
config
once
and
be
done
with
it
and
just
use
it
so
in
this
ticket
that
I
put
there.
D
So
I
expressed
concern
that
for
the
cases
such
as
mobile,
where
the
people
are,
you
know
roaming
more
frequently
than
not,
but
the
connections
are
very
flaky.
You
know
it
is
not
good
to
have.
D
You
know
a
constant.
You
know
a
second
connection
right
or
even
yeah.
B
D
B
D
D
And
and
they.
D
They
all,
I
think,
in
the
ticket
tigran.
I
think
he
also
suggested
you
know
why
not
look
at
http
instead
of
websocket.
You
know
you
just
do
a
polling
but
even
polling.
I
feel
like
it's
unnecessary
because
you
know
these
config
updates
are
rare.
B
So
totally
yeah
I
mean
why
do
you
need
it?
After
just
when
you
start
the
app,
I
mean
at
least
for
an
app
that
you
are
collecting
data
yeah.
Why
would
you
dynamically
change
your
configuration
based
on
something
that
happens
on
a
backend?
B
Yes,
I
see:
do
you
see
a
use
case
for
a
mobile
app
really
for
dynamic
configuration?
I
mean
I
can
understand
configuring
it
once
when
you
start
the
app
but
dynamically
configure
during
the
run
of
the
app
that
usually
can
run
one
minute
two
minutes,
ten
minutes
as
much
and
the
next
time
we
will
start
again
yeah
it's
it's
hard
for
me
to
to
to
invest
in
that,
to
think
that
can
be
useful
really,
except
for
a
really
rare
case,
maybe,
and
that
will
probably
be
handled
better
from
from
the
user.
B
That
really
needs
that
that
having
a
general
dynamic
configuration
for
the
ex
for
the
exporter
policies,
because
that's
the
only
thing
you
are
going
to
change,
I
mean
your
exporter
policies.
If
you
want
to
export
more
or
less
or
send
faster
or
slower,
I
don't
see
many
other
things
that
are
useful
in
a
mobile
user
or
even
in
a
client
application
yeah.
B
I
can
understand
that
with
if
you
have
a
long-running
collector
that
has
been
running
for
months
or
days
and
something
happens
on
the
other
side
and
you
want
just
to
reduce
latencies
or
improve
whatever,
but
in
a
client
app.
I
think
it's
totally
over
engineering
and
the
really
small
cases
needed
it
probably
will
will
prefer
use
another
kind
of
logic
to
not
just
configure
open
telemetry,
but
many
other
things.
D
Yeah,
I
think
I
think
I
see
what
you're
saying
it
definitely
makes
sense.
So
I
don't
know
I
think
I'm
confused
as
well.
So
I
think
what
I
proposed
in
that
ticket
is
is,
is
something
very
you
know
lightweight.
You
know
strategy
where
you
know.
Can
we
have
the
otlp
response?
D
B
Even
there
I
mean,
usually
they
restart
from
time
to
time
those
apps
yeah
even
in
other
stuff,
and
we
are
thinking
that
we
are
just
middleware
in
an
app
that
does
many
other
things
so
keeping
resources
for
us
just
for
configuring,
something
dynamically
that
for
something
that
doesn't
last
much.
I
I
I
I
don't
really
I
I.
I
will
need
to
see
a
use
case,
real,
a
real
use
case
that
makes
sense.
B
Okay,
make
sense,
yeah
yeah
I'll,
just
maybe
I
am
to
direct
well
but
yeah.
I
really
don't
see
even
on
a
desktop,
I
mean
yeah.
If
you
really
have
that
needs.
Probably
you
will
need
that
for
many
other
things
that
just
open
telemetry
and
you
can
just
end
your
exported
and
reopen
one
with
a
new
configuration.
That's
not
an
issue,
I
think
I
mean
than
having
something
that
automatically
runs
more
than
you
expect.
B
Okay,
because
you
can
always
yeah
finish
the
tracer
and
and
open
another
with
another
configuration
whenever
you
want
and
you
won't
lose
anything
you
could
even
probably
start
with
the
same
trace
id
you
wanted
before
and
you
can
keep
sending
data
with
a
new
configuration.
D
B
D
B
Okay,
so
then
the
next
topic
is
just
the
metric
refresh
from
bryce.
I
just
opened
here
your
new
commit.
I
think
we
don't
have
much
time
now.
A
Yeah,
it's
it's
not
too
big
of
a
deal.
Yeah.
A
Let's
look
at
the
yeah,
my
dog
needs
to
go
outside,
so
let's
do
this
quick
he's
getting
fussy,
let's
see
so,
oh,
I
need
to
clean
up
some
header
things,
but
so
I've
added
some
interesting
kind
of
protocol
for
the
observer
pattern,
which
might
be
worthwhile
looking
at
just
the
kind
of
I
used
a
I
have.
This,
like
idea
of
the
observer,
will
pass
a
like
a
result.
A
An
observer
result
object
into
the
callback
that
can
be
set
the
data,
and
then
it
will
take
that
so
there's
I
don't
know
where
that
is
exactly,
but
the
other
main
big
change
here
is
under
the
reader
and
so
the
maybe
well,
maybe
it's
more
that
interface
between
the
yeah,
the
reader,
doesn't
really
have
a
whole
lot
in
it.
At
the
moment,
it's
more
the
interface
between
the
meter
provider
and
the
reader
and
the.
A
Yeah
he's
trying
to
help
too
yeah,
but
yeah.
So
I
think
one
of
the
changes
that
I've
made
is
I've
just
added
the
instead
of
having
a
dictionary
of
of
meters.
I
just
made
it
an
array
of
meters
so
that
there's
no
lookup
on
the
instrument
instrumentation
library
info.
A
I
think
one
thing
that
I
want
you
to
take
a
closer
look
at
is
just
make
sure
that
the
the
thread
safety
of
some
of
the
interactions
between
the
shared
states
and
also
like
the
meter
provider
meter
array.
From
my
understanding,
the
way
swift
works
is
it's
it'll
pass
arrays
by
value.
So
if
you
do
a
get
on
an
array
and
return
that
the
that'll
be
an
independent
array
from
the
one
that's
actually
being
stored
in
an
object,
is
that
correct?
Yes?
Yes,
yes,.
B
B
It's
not
a
it's,
not
a
deep
copy
of
the
pointer
that
you
store.
So
if
you
yeah.
A
Yeah
my
concern
is
about
inserting
and
reading
the
array
itself.
So
if,
if
we're
reading
the
array,
while
it's
being
updated,
then
that
might
be
a
problem.
But
if
it's
just
getting
a
copy
of
a
list
of
the
pointers,
then
I'm
not
too
concerned
about
it.
But
yeah.
You
can
take
a
closer
look
at
that
in
the
the
meter
provider.
B
Yeah,
I
will
take
a
look
yes
probably
tomorrow,
for
me:
yeah.
A
B
A
And
the
other,
the
other
thing
or
my
next
step
is
probably
going
to
be
fleshing
out.
The
actual
stable
meter
object
as
well,
which
is
stubbed
out
on
the
return
values
for
for
all
of
the
different
meters
that
it
can
generate,
or
all
the
different
metrics
or
whatever.
D
B
B
Great
yeah
yeah,
I
think
we
will
yeah
the
the
the
the
locking
mechanism
is
something
that
we
we
we
must.
We
must
control
yeah.
B
A
And
but
then
elsewhere
there
might
be
a
right.
A
A
Okay,
all
right
cool
yeah,
just
to
leave
comments
on
the
on
the
pr,
and
we
can
go
over
in
more
detail
next
time
too.
B
B
Nice
cool,
so
thanks
for
attending
it
has
been
our
really.