►
From YouTube: 2022-04-20 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
So
yesterday
we
we
talked
for
about
a
half
hour
yesterday
and
but
we
did
not
go
through
the
the
poc
santosh.
A
So
if
you
want
to
just,
if
you
want
to
talk
about
it,
that
could
be
one
topic
for
today
and
then
the
other
thing
that
I
just
wanted
to
like
to
do
today
is
just
see
where
we
are
and
what
else
we
need
to
do
before.
We
can
open
the
proposals
with
all
taps.
C
Okay,
we
can
talk
about
some
other
topic.
While
I
get
the
setup
I
need
like
five
minutes.
I
wasn't
prepared
sorry.
A
Okay,
no.
C
A
A
That
he
was
saying
that
from
a
modeling
perspective,
you
know
he
just
doesn't
think
that
session
data
belongs
on
the
resource,
since
the
resource
kind
of
identifies
the
service
or
the
application.
A
So
I
I
guess
my
question
is
like:
is
it
oh,
I
mean?
Is
it
okay
like
to
to
think
of
the
resource
as
kind
of
optimization
or
for
efficiency
of
reuse
like
sending
sending
data
over
the
wire
or
like
do
we
need
to
be
really
strict
about
the
data
modeling
here.
B
B
We
only
have
the
ability
to
attach
attributes
to
spans,
so
spans
get
a
name
or
an
attribute,
but
it's
not
currently
possible
to
give
a
name
and
an
attribute
to
to
a
trace
which,
which
does
actually
come
up,
there's
often
a
case
where
people
want
things
like
a
user
id
or
account
id
or
project
id
or
some
some
kind
of
identifier.
B
That
applies
to
every
span
in
the
trace
and
what
people
currently
have
to
do
if
they
want
that
in
open.
Telemetry
is
actually
put
that
identifier
in
the
baggage
and
then
apply
it
to
every
span.
B
B
Well,
I
I
feel,
like
we've
identified,
that
session
ids
get
potentially
applied
to
things
that
aren't
encapsulated
in
traces
right.
I
think
we
have
concrete
examples
of
events
that
that
don't
don't
have
a
bounding
trace.
C
Yeah
it's
tight,
but
I
was
thinking
that
even
if
we
have
an
attribute
at
trace
level,
the
the
problem
we're
talking
about
is
that
you
know
in
in
a
given
time
span
which
we
call
as
a
session.
You
know
there
are
multiple
traces
that
get
that
come
out
and
you
know
we
are
duplicating
that
id.
You
know
in
each
signal,
even
if
it's
at
the
trace
level,
we
are
looking
in
a
different
dimension.
So
the
problem
remains
the
same.
B
Yeah
yeah,
and
we
also
identified
that
there's
no
concept
of
like.
B
A
global
trace
or
like
a
root,
trace
object
to
to
put
this
information
on.
So
there's
like
this
additional
modeling
problem
that
we
run
into
of,
like
you
have
to
store
this
session
id
somewhere
and
apply
it
every
time.
You
start
a
trace
and
that's
like
kind
of
problematic.
C
Yeah,
I
think
that
the
other
approach
that
josh
mentioned
in
in
the
ticket-
he
responded
to
one
of
your
comments
on
slack,
where
they
were
going
in
the
direction
of
resource
having
and
identifying
attributes
and
describing
descriptive
attributes
so
that
the
describing
attributes
a
second
category
of
attributes.
You
know
it's
okay
to
change,
but
I
think
the
question
is:
how
do
we
indicate
that
which
ones
are
identifying
attributes
that
identify
the
resource
and
so
are
not
mutable
and
the
other.
B
Right
can
be
yeah,
I
I
think
he
he
wants
something
hey
I
mean
I
would
call
this
an
identifying
attribute,
not
a
descriptive,
like
there's
actually
like
two
things
going
on.
Josh
josh
tends
to
layer
a
bunch
of
stuff
on,
but
he
there's
this
one
concept
of
like
not
every
attribute
you
attach
to
spams
or
resources
or
anything
is
something
you
are
trying
to
use
as
an
index
in
the
back
end.
Right
like
like
it
may
not
have
a
value.
B
That's
appropriate
for
being
indexed
like
a
log
message
is
an
example
of
something
you're,
not
you're,
not
really
going
to
index
everything
based
on
the
contents
of
the
log
message
necessarily,
but
you
want
that
information
there,
because,
when
you're,
looking
at
that
piece
of
data,
like
that's
descriptive
information
that
like
helps
the
human,
you
know
understand
something
about
what's
going
on,
but
you
wouldn't
use
it
as
an
index.
B
I
think
the
thing
he's
also
talking
about
in
this
case,
if
we're
going
to
have
updatable
resources
or
if,
after
the
fact
we
want
to
attach
additional
resources
or
other
information,
then
you
need
something
like
an
instance
id
like
to
associate
all
that
information
with.
B
So
I
think
that's
that's
the
thing
he's
that
that
was
what
I
read
into
that
comment
by
him
is.
If
you
had
something
like
an
instance
id
that
didn't
change,
then
it
would
be
a
lot
easier
to
start
attaching
additional
information
about
that
particular
instance
of
a
service
you
know
or
or
a
browser
application,
or
something
like
that,
provided
you
had
some
stable
identifier
like
that,
for
example
like
config
information
that
we
wouldn't
want
to
send
as
a
resource
on
every
batch.
B
But
let's
say
on
a
service:
you
want
to
to
hoover
up
the
configuration
file,
scrub
it
and
send
that
along
and
and
do
some
analysis
on
that,
you
need
to
associate
that
configuration
file
with
like
an
instance
of
the
service,
so
you
can
glue
them
together
so,
but
we
don't
actually
have
a
required
identifier
like
that.
Currently,
currently,
there's
no
required
identifier
like
service
instance
or
sdk
instance,
or
something
like
that.
There
are
all
optional
things
that
the
end
user
might
might
put
on
there,
but
only
service.
B
Yeah-
and
we
don't
I
and-
and
we
don't
generate
these
things
so
in
the
case
of
like
this
instance
id
we
would
want
to
take,
we
want
to
pick
an
identifier
and
say
if
the
user
doesn't
supply
it,
then
we
like
generate
a
random
id
number.
You
know
128
bit
id
and
and
attach
it
to
ensure
that
it's
already
always
there
in
service
name.
We
attach
something
like
default
service
or
something
generic
that
wouldn't
be
helpful
here.
B
So
I
think
that's
that's
useful.
I
think
what
what
yuri
is
suggesting
around
like
trace
attributes
is
that's
like
another
helpful
thing
we
should
add
to
open
telemetry,
but
but
it
seems
to
me
that
session
is
a
is
a
resource
like
that
does
seem,
I'm
I'm
still
convinced
that
it's
that's
the
appropriate
place
to
put
this.
It's
it's
a
way
of
describing
all
of
the
information
coming
out
of
that
coming
in
that
batch
of
data,
not
just
traces,
so
so
I
can.
B
B
This
is
the
the
beginning
of
the
the
next
stage
of
this
is
we're
gonna
go
to
the
wider
audience,
and
this
is
why
it
would
be
helpful
with
this
prototype
that
we
make
that
the
example
app
that
we're
using
it
with
includes
examples
of
non-trace
events
and
data
that
we
want
the
session
attached
to
that's
that's.
I
think
I
think
this
is
becoming
clear.
B
A
C
Okay,
so
let
me
show
you
what
I
have
so
the
api
yeah.
The
way
this
needs
to
be
used
by
the
end
application
developer
is
you.
This
is
a
javascript
in
the
browser,
so
you
basically
create
an
instance
of
session
provider
and
you
add
a
session
manager
to
it,
and
then
you
register
it
with
the
provider
so
that
the
session
manager
is
the
one
that
will
be
responsible
for
tracking
when
to
start
and
stop
the
session,
and
it
will
use
this
provider
instance
to
update
the
resource
associated
with
it.
C
Start
the
end,
you
know
when
this
is
initialized
and
when
you
send
a
span
you
know
you
can
see
that.
C
You
know
there
is
a
there's,
an
attribute
at
the
resource
level
that's
available
and
then
in
this
sample
example
session
manager.
I
change
this.
I
reset
the
session
every
15
seconds
so
right
now
it
is
71
and
let's
say
I
try
again.
C
Okay,
I
don't
know
what's
going
on,
but
basically
the
idea
is
that
you
know
this
when,
when
you
do
an
end
session
and
create
session,
it
will
update
the
resource,
because
the
session
manager
has
has
a
pointer
to
the
trace
provider
and
and
then,
whenever
the
session
is
reset,
it
will
update
the
resource.
It
will
basically.
C
That's
attached
to
the
trust
provider
same
as
what
you
were
suggesting
did
the
one
generic
challenge
you
know,
irrespective
of
which
approach
we
take.
I
noticed
is
that
this
is
it
is
currently
not
we.
Ideally.
You
know
we
want
every
event.
That's
emitted
from
this
from
this
resource
to
automatically
have
this
session
id,
but
the
problem
is
we.
We
need
to
explicitly
register
our
session
manager
with
every
provider
right
with
beat
address
provider,
metric
provider
or
a
log
record
provider
tomorrow.
C
But
then,
if
there
are
multiple
sdks
simultaneously
in
the
same
process,
then
I
don't
know
if
there
is
an
easy
way
to
get
a
handle
to
each
of
those
providers
at
the
at
the
top
level
open
telemetry
level-
I
I
haven't
looked
into
it,
but
that's
one
potential
problem.
B
So
so
I
have
a
suggestion
there
santosh,
which
is
we
need
to
extract
out
a
concept
of
a
resource
provider,
so
I
see
trace
providers.
You
know
all
these
different
metric
yeah,
all
the
different
sdk
components
that
want
to
access
resources,
rather
than
getting
a
map
of
resources
to
get
a
resource
provider
that
the
session
manager
gets.
B
B
And
having
a
resource
provider
concept
also,
I
think,
will
solve
nev's
various
issues
with
this
stuff,
where
you
are
end
up
with
different
multiple
sdk
objects
that
that
maybe
have
different
ownership
and
need
access
to
like
different
different
resource
providers.
So,
okay.
C
Okay,
so
you're
basically
saying
that
each
of
the
existing
providers
should
should
have
should
be
configured
with
a
resource
provider
and
right.
C
Of
having
you
know,
this
resource
as
a
local
parameter
method
parameter.
D
C
They
should
each
time
they
should
get
it
from
the
research
provider,
but.
D
C
C
But
the
way
this
is
currently
done
is
the
the
tracer
provider
hands
over
a
resource
object
to
the
tracer,
which
gives
it
further
to
the
span.
B
B
Yeah,
I
think
so
because
that's
that's
the
place
where
you
want
right
there,
where
you're,
looking
at
the
when
the
when
a
tracer
constructs
a
span
right
and
attaches
resources
to
the
span.
That's
the
moment
when
you
want
that
particular
instance
of
the
resources
in
the
resource
provider
right
so
it
attaches
it
to
the
span
and
then,
if
at
any
point
after
that,
the
resources
in
the
resource
provider
change
it.
It's
not
going
to
mutate.
The
span
right.
B
It'll
get
that
particular
immutable,
a
pointer
to
like
that
particular
immutable
set
of
resources,
but
because
the
resources
can
now
change,
you
need
to
hand
this
provider
around
to
everything.
That's
that's
going
to
be
generating
things
like,
like
spans
and
events
and
stuff
like
that.
Okay,.
C
Yeah,
I
think
it
surely
will
simplify,
because
you
only
have
to
update
at
one
place
today
here
I
have
to
update
that
the
dresser
provider,
then
on
each
of
the
tracer
objects.
B
And
events
like
like
logs
when
that
shows
up
it'll,
be
the
same
deal
it'll
be
efficient,
though,
because
we're
just
handing
out
pointers.
D
C
C
Yeah
only
thing
is,
it
will
be
a
bigger
change
to
the
stable
spec,
but
I
guess
it's
it's
a
good
thing
anyways.
I.
B
Think
it's
the
because
what
we're
saying
is
we
need
updatable
resources
right,
like
I
think,
we're
saying
that
the
component,
the
thing
we
actually
are
proposing
is
like
a
resource
provider.
Once
we
have
a
resource
provider,
then
it's
easy
to
build
a
session
manager.
Yeah
yeah,
makes
sense.
D
D
C
Well,
there
is
one
ticket
that
somebody
else
also
asked
for
a
lazy
provider
or
a
lazy
resource
where
they
have
some
attributes
on
the
resource
to
start
with,
but
a
few
seconds
later
you
know
they
want
to.
They
will
get
all
the
required
attributes,
but
the
concern
is,
you
know
some
signals
would
have
emitted
by
then
you
know
they
would
not
have
those
attributes
so.
B
C
C
You
know
if,
if
that
goes
through,
then
you
know,
we
can
say
that
you
know
our
resource
is
still
this
mobile
or
this
browser
instance.
But
then
there
is
also
some
non-identifying
attribute
called
session
ide.
That's
also
that
changes
over
time
on
the
same
resource,
yeah.
B
But
it
it's
it's
true
that
if
you
you
had
a
you,
updated
the
concept
of
a
resource
to
if
what
the
resource
provider
produced
was
actually
two
things
like
the
static
resources
and
then
also
like
lazy
resources
that
you
ask
for
later,
you
could
maybe
defer
some
of
you.
You
could
push
down
where
you're
waiting
for
those
resources
to
resolve
into
deep
into
the
exporter,
but
that's
like
it's
like
a
whole
trust
me.
It's
like
a
whole
other
ball,
wax
that
I
don't
think
this
group
has
to
solve.
Yeah.
D
B
You
you
could
one
thing:
this
could
clean
up
in
the
javascript
sdks
right
now,
the
whole
sdk
lazy
loads
in
order
to
wait
for
these
resources,
and
you
could
move
that
out
to
like
just
the
resource
manager,
lazy
loads
in
this
fashion,
so
that,
if
you
didn't
have,
if
you
weren't,
trying
to
lazy
load
resources
or
defer,
wait
for
resources
to
resolve
you
could
you
could
load
the
sdk
synchronously?
B
B
Okay,
due
to
the
way
callbacks
and
asynchronous
stuff
in
javascript
changes
the
way
you
there's
no
top
level
of
weight
in
javascript
still
today,
so
so
it
actually
like
totally
rearranges
how
you
write
that
startup
code
in
a
way
that's
really
awkward,
but
for
other
languages.
This
is
like
not
a
big
deal.
You
just
you
just
wait
for
that
stuff
to
resolve.
At
the
beginning
of
your
when
you're
loading,
your
service.
C
I
think
someone
just
shared
this
ticket
several
his
from
cisco
too.
He
just
created
these
tickets
hours
ago.
B
Right
yeah,
but
you
can't
do
that
because
there's
some
resources
that
are
asynchronous
by
nature,
because
you
actually
have
to
make
an
api
call,
even
a
series
of
api
calls
to
get
these
resources
like
there's
a
bunch
of
like
common
kubernetes
resources
that
can
only
be
acquired.
This
way,
plenty
of
cloud
providers
work.
This
way
where
you
have
to
like
make
an
api
call
to
to
get
access
to
some
of
the
resources
you
want
to
attach.
So
it's
it's.
It's
just
like
comes
with
the
territory,
unfortunately
yeah,
maybe
not
on
the
browser.
B
D
So
with
chromium,
there's
a
recent
change
in
terms
of
identifying
what
version
of
the
os
that
you're
on
like
right
now,
if
you
fire
a
fire
up,
a
chrome
oil
or
edge
chromium
and
say,
look
at
the
user
agent
to
figure
out
what
version
of
windows
you're
running
on
you'll
actually
be
told
this
windows
10.
Even
if
it's
windows
11.
D
so
there's
a
an
asynchronous
call.
You
have
to
make
called
get
hired
from
your
values
to
ask
for
what
that
version
is,
and
the
user
may
be
prompted
so
either
it'll
be
rejected,
immediately
return
in
a
small
amount
of
time
or
it
could
be
ages
before.
D
And
I'm
having
a
big
discussion
internally
with
a
bunch
of
teams
about
who
should
be
doing
this.
There
are
other
ways
to
do
it
on
the
server
and
then
feed
it
back
to
the
client,
but
everyone
yeah.
B
But
yeah,
that's
that
does
suck
it
also.
This
is
a
pattern
that
it's
a
slightly
obnoxious
for
servers,
but
I
think
this
really
sucks
for
clients
to
be
waiting
on
a
resource
because
with
server
taught
startup
time
is
not
nearly
as
critical
as
startup
time
for
clients
right,
like
that's
actually
on
the
hot
path
to
the
like
you're
measuring
the
latency.
For
how
long
your
client
takes
to
boot
up,
because
that
will
piss
off
your
users
if
it's
sitting.
B
D
D
May
be
prompted
in
the
process
of
doing
this
yeah
and
then
you've
got
like
client-side
requests
redirects,
so
I
think
they
could
come
in
effectively.
Javascript
runs
and
sends
you
somewhere
else
straight
away.
B
B
But
at
any
rate
I
I
like,
where
you're
going
with
this
centos,
I
think
it's
great,
I
think
it
would
be.
I
do
think
we
need
to
take
the
next
step
to
extract
the
resource
provider
out
because
that's
actually
the
when
it
comes
to
like
the
otep
we're
going
to
make.
I
think
that's
actually
how
we
want
to
encapsulate
this
otep
is
to
make
this
like
resource
provider
otep
and
then
basically
have
that
proposal
point
at
our
like
rum
session
manager.
B
Such
you
know,
like
whatever
proposal
we
have,
that
encapsulates
the
rest
of
the
stuff.
We
need
for
rum
to
work
around
just
modeling
like
the
rest
of
the
modeling,
that
I
think
we
already
have
documents
showing
it's
basically
like
that
proposal.
That
includes
the
section
on
session
management
that
says
like
like
there's
no
good
place.
To
put
it.
We
think
it
should
go
as
like
an
updatable
resource
and
then
have
this
other
totally
separate
otep
for
for
updatable
resource
providers.
B
That
show
shows
how
that
that
should
work,
and
then
you
know-
and
maybe
as
part
of
that
proposal
getting
into
the
thing
josh
was
talking
around
around
having
like
a
some
kind
of,
like
instance,
identifier,
that's
always
present
as
a
way
to
solve
the
problem
of
like
well
for
updating
the
resource.
How
do
we
not
con?
How
are
analysis
tools
supposed
to
understand
when
it's
an
updated
resource
versus
an
entirely
new
instance
right
now?
B
C
Actually,
on
that
topic
I
asked
martin
also
to
find
out,
but
in
our
product
at
cisco
we
don't.
You
know,
map
every
attribute
in
that
resource
to
the
entity,
because
there
are,
you
know,
like
the
telemetry.sdk.
You
know
I
noticed
recently
there
are
some
attributes
called
telemeter.sdk.
C
You
know
we
don't
put
them
in
in
our
internal
entity
objects.
So
so
not
every
research
attribute,
you
know,
is
already
you
know
identifying
the
resource,
although
there
are
some
corner
use
cases
that
I
think
somebody
mentioned.
You
know
the
reason
why
those
attributes
are
there
on
the
resource.
Today,
the
telemetry
sdk
name,
telemetry,
sdk
version.
I
don't
know
why
they
are
really
at
the
resource
level
because
they
don't
identify
the
resource.
C
D
Okay,
okay,
so
random
thoughts,
less
clarification,
probably
many
for
ted
in
terms
of
what
he's
thinking
so
we
could
model
the
resource
provider
as
effectively.
You
have
a
list
of
resource
providers
and
therefore
a
session
manager
could
be
just
another
resource
provider
or
we
could
have
a
resource
provider
which
has
the
concept
of
a
pluggable
resource
value
source
or
something.
What
are
your
thoughts.
C
Yeah,
so
I
guess
it's
something:
like
your
resource
provider
has
listeners
on
each
of
their
attributes.
You
know
which
would
be
responsible
for
updating
those.
You
know
attributes.
Is
it
something
like
that.
D
You
know
it's
probably
more
a
case
of
you
could
say:
resource
x
has
provided
a
y,
so
you
could
have,
like
a
you,
know,
multiple
resource
providers.
So,
as
I
said
earlier,
the
session
manager
could
just
be
a
resource
provider
which
happens
to
provide
a
resource
called
session
id.
D
D
Yes,
so
so
so
what
level
are
the
attributes
defined?
Because
you've
got
to
provide
a
return
more
more
than
one
attribute
or.
B
I
nev,
I
think
that
that
sounds
like
a
little
over
complicated,
but
you
could
you
could
easily
make
a
a
resource
provider
that
that
was
like
a
rapper
around
multiple
resource
providers
right,
like
a
resource
provider
that
when
you
initialize
it,
you
know
you're,
saying
pull
off
like
this.
This
list
of
these
keys
you
get
from
this
provider,
these
keys,
you
get
from
this
other
provider
and
the
rest,
the
keys
you
get
from
this
provider
or
something
like
that
you
could.
You
could
make
a
resource
provider
that
did
that
internally.
B
D
Trying
to
get
get
like
a
mixed
mix
yeah,
I
I
wouldn't
go,
select
keys.
I'd
just
say
you
know,
for
this
provider
give
me
the
list
of
keys
and
just
merge
them
all
together,
and
then
you
would
either
do
mutable
or
non-mutable,
depending
on
which
way.
B
You
you
could
also
go
the
the
other
way
if
you're
saying,
like
you,
want
to
hand
a
provider
that
actually
represents
a
list
of
providers
so
that
to
like
a
session
manager,
so
that
when
you
call
like
update
when
you
update
the
session
id
on
the
provider
handed
to
the
session
manager
under
the
hood,
it's
actually
updating
like
five
resource
providers
or
something
so
that.
C
D
Yeah,
so
so
that
that's
really
where
the
question
was
coming
from,
which
around
do
we
do
as
a
push
or
a
pull
model?
You
have
the
session
manager,
push
it
out
to
the
resources
or
have
the
the
resource
manager
just
happen
to
pull
it
from
the
session
manager.
So
hey.
B
D
Do
we
want
to
define
it
as
this
is
just
a
resource
provider
and
then,
if
you
want
something
more
complicated,
you
go
build
a
complicated
resource
provider
yeah
or
do
we
just
say
it's
a
set
of
resource
providers
that
gets
passed
around.
B
B
For
some
reason,
I'm
spacing
on
their
name
right
now,
but
the
the
stuff
that
extracts
trace
context
context
providers,
whatever
we
call
those
things
that
do
things
like
I'm
looking
for,
like
w3c,
trace
context,
headers
or
I'm
looking
for
zipkin
headers,
there's,
like
often
cases
where
you
end
up
actually
wanting
for
like
a
list
of
different
header
types,
because
you
might
be
getting
requests
from
older
services
that
are
still
running
zip
in
or
they're
still
they're
still,
they
haven't
moved
over
to
like
the
w3c
headers,
yet
or
whatever,
and
so
we
encapsulate
that
by
just
having
like
a
more
complicated
implementation
that
that
does
all
of
that
that
trickiness,
but
it
doesn't
end
up,
it,
doesn't
end
up
leaking
into
the
the
interfaces
that
you're
passing
around
it's
just
under
the
hood.
D
So
so,
in
that
case,
in
the
otap
we
could
just
define,
is
we
have
a?
We
have
this
resource
provider?
The
sdks
can
provide
a
default
one
which
effectively
makes
them
immutable
like
it
is
today
and
just
call
out
that
if
they
want
more
complicated
ones,
they
just
build
one
that
implements
the
same
interface.
B
A
I
have
a
couple
questions
is
the
is
the
resource
provider,
something
that
is
like
central,
like
there's
like
a
one-to-one
relationship
between
sdk
and
resource
provider,
or
do
you
create
it
and
pass
it
on
like
all
these?
Like
trace
provider
session
manager,.
B
You
you
would
it's
a
thing
that
you
would
pass
around
to
all
of
these
objects,
as
you
initialize
them,
like
anything
that
today
gets
resources
handed
to
it
would
get
a
resource
provider
handed
to
it
until
you
get
all
the
way
down
to
the
leaf.
B
The
moment
where
you
are
trying
to
actually
attach
the
current
set
of
resources,
which
would
be
like
span
creation
and
event
creation,
but
all
the
tracer
providers
and
all
of
those
things
would
get
a
resource
provider
and
actually
like
to
your
point
nev.
It's
two
interfaces
right.
We
can
say,
there's
the
resource
provider
interface,
that
only
has
get
resources
on
its
interface
and
then
there's
a
separate
interface.
That's
like
the
updater
interface,
or
something
like
that
like
if
that
makes
sense.
B
B
D
B
A
So
good,
I
also,
and
also
just
to
clarify
one
instance
of
resource
provider,
always
manages
only
one
resource.
A
C
D
No,
I
would
think
it
because
it
give
me
a
set
of
resources
and
then,
at
the
point
of
putting
those
onto
the
the
span
or
during
exporting
they
get
merged.
So
slightly
contrived
versions.
You
might
have
a
a
resource
provider
to
get
the
the
browser
resources
so
which
identifies
the
name,
the
user,
agent,
etc.
D
It
would
be
a
case
of
that
would
be
more
than
one
resource.
This
would
be
the
name,
the
version,
the
the
os
host
and
the
version
etc.
A
C
Typically,
a
provider,
I
think
there
are
two
points
that
I
think
now
I
think
you
are
still
referring
to
the
individual
properties
or
attributes
as
a
resource
which
is
slightly
different
from
the
current
hotel
terminology.
C
Like
like
a
tracer
or
a
tracer
provider,
when
you
ask
for
a
tracer,
you
pass
on
the
instrumentation
library
name
and
the
version
right,
so
you
ask
for
a
for
an
object
with
a
certain.
You
know
identifying
properties,
so
so
here.
Similarly,
you
have
to
ask
the
provider
to
give
you.
Even
if
it's
let's
say
you
know
the
the
browser
version
or
a
browser
name.
You
have
to
ask
hey,
give
me
this
particular
resource.
The
latest
version.
D
D
I
I
think,
as
ted
said,
we
just
have
a
single
method
called
get
resources
and
it
just
returns
them
all.
Okay
and
then
you
can
have
the
more
complicated
ones.
On
top
of
that
that
affect
me
as
a
provider
where,
internally,
it
has
a
bunch
of
other
providers
and
that
calls
get
resources
on
those,
but
it
still
just
returns
a
single
set
of
resources.
C
D
A
C
You,
instead
of
using
that
static
resource
object,
you
ask
the
provider,
hey
get
me.
The
latest
version
of
the
resource
object.
Okay,
so
it's
going
to
be
not
a
set
of
things
can
be
one
instance,
one
instance
of
the
entire
resource
object,
which
will
have
individual
attributes.
D
A
C
A
different
topic
I
in
the
log
sig
later
today,
I'm
gonna
present
the
logs
api,
which
will
be
used
for
the
events
as
well.
C
And
it's
essentially
a
pretty
simple
api,
you,
you
get
a
logger
provider
and
then
you
from
that
you
build
a
log
record
object
and
then
on
that
you
set
all
its
properties
and
there
are
some
convenience
method
where
we'll
say
set
event.
Instead
of
an
ad
event,
it's
a
set
event
which
takes
a
name
and
attributes.
C
C
Yeah
so
yeah
it
will
be
based
on
the
builder
pattern.
There
are
examples
here.
D
C
Yeah,
I
know
okay
I'll
bring
it
up.
Yeah,
for
example,
this
log
record
builder
dot
build,
you
know,
could
be
just
one
method
calls
you
don't
need.
Two
method
calls
yeah.
C
I
have
this
question.
You
know
in
my
mind
all
the
time
like.
Why
are
we
saying
we
need
things
to
be
efficient
only
on
the
browser.
If,
if
things
we.
D
C
D
D
Yeah
it
does
like
when
I
was
doing
java
development
many
moons
ago.
D
The
builder
pattern
was
common,
which
is,
I
guess,
where
this
comes
from:
I'm
not
a
big
fan
of
it
because
of
the
perf
overhead
yeah,
unless
you're
actually
playing
with
immutable
objects
and
then
and
then
the
the
builder
pattern
makes
sense,
because
you
have
a
builder,
then
then
generates
your
immutable
object.
But.
B
Yeah
I
mean
I
feel
like
this
is
kind
of
like
builder
versus
options
is
kind
of
like
a
language
specific
pattern.
Yeah,
you
know
in
some
languages
like
java,
like
the
builder
pattern,
is,
is
what
people
want
for
configuring
things
and
other
languages
like
go
these?
B
You
don't
have
a
builder
you
just
have
you
just
have
optional
options,
you
just
have
parameters,
you
know
and,
and
that's
it's
it's
just
kind
of
like
we,
I
think
when
we
try
to
write
our
specs.
We
try
to
avoid
that
kind
of
defining
things
specifically
as
a
builder
or
not,
we
just
say
like
when
you
create
this
object.
B
These
are
the
the
parameters
for
creating
it.
So
when
you
create
a
new
span
like
these
are
the
parameters
you
can
set
on
it.
These
are
the
required
ones,
use
the
optional
ones
and
then
in
various
languages,
people
interpret
that,
as,
as
you
know,
creating
a
builder
object
or
not,
but
but
we
don't
have
to
do
that
at
like
the
spec
level.
B
C
C
Yeah,
I
think
ted.
I
think
this
so
span
has
an
ad
event
right
and
the
span
has
an
ad
event,
because
you
can
have
multiple
events
on
a
spam,
whereas
on
a
log
record
object,
I'm
calling
it
as
a
set
event
instead
of
an
ad
event,
but
it
takes
the
same
name
and
attributes
yeah.
C
B
Yeah,
so
that
that
that
would
fit
in
with
with
kind
of
how
we
do
span
names
and
it
would
make
the
mapping
it
would
make
it
very
easy
to
then
have
this
mapping
between
whether
you
add
you're,
adding
this
event
through
the
existing
like
span
event
api
or
adding
it
through,
like
the
new
like
log
event,
api,
it's
easy
to
then
make
100
mapping
right.
So
you,
I
think,
you're
correct
by
having
this.
B
This
interface
look
the
same,
and
then
it's
just
a
matter
of
picking
like
stable,
attribute
keys
that
these
things
all
map.
C
To
okay,
then,
on
on
the
topic
of
how
do
we
keep
the
logs
as
logs
and
events
as
events,
but
still
use
the
same
data
model?
By
by
you
know,
events,
I
think
we
will
always
use
a
set
event
interface,
although
the.
D
C
Thing
you
could
use
you
know,
set
attributes
also
and
the
there's
a
subtle
challenge
here,
where,
if
let's
say
you
use
you,
you
mandate
as
a
spec
that
all
the
event
creation
should
also
always
use
set
event.
That
way,
our
presence
of
this
event.name
attribute,
you
know,
can
be
the
distinguishing
you
know
factor
between
logs
and
events
yeah,
but
but
the.
C
The
other
methods
are
available
too,
so
people
could
create
events
but
not
use
the
set
event
method
and
and
and
they
can
go
wrong-
we.
B
We
did
discuss
this
in
the
the
log
sig.
At
one
point,
I
think
the
you
know
the
conclusion
we
came
to
was
like
there
is,
generally
speaking,
there
is
no
like
strict
distinction
between
logs
and
events
and
settled
on
like
really
it's
just
yeah,
the
presence
of
event,
dot
name
right
like
in
other
words,
you
you
have
the
way
we
do
semantic
conventions
right
is
you
have
like
a
name
spacing?
B
So
if
this
is
like
an
http
span
or
an
http
event,
then
it's
http
dot,
something.
If
this
is
an
event,
then
there's
like
the
event
name,
space
which
right
now
includes
name
as
okay
as
a
field
and
we're
just
saying
like
if
that's
present,
then
this
this
counts
as
an
event
exactly
okay
and
likewise,
then,
if
we
wanted
to
differentiate
between
like
different
kinds
of
events,
that
would
actually
be
that
like
if
there
were
like,
if
it
was
like
a
browser
event.
B
Yeah
yeah
then,
but
it's
more
that
there'd
be
like
a
set
of
attributes
that
make
it
specifically
a
browser
event
versus
a
mobile
event.
Right,
like
there's
these
things
like.
B
A
signal
level
right,
those
can
come
from
the
resource
or
for
somewhere
else
so
and
that
in
general,
the
pattern
that
we're
trying
to
use
is
just
detecting
the
presence
of
those
name
spaces
in
in
various
places.
Okay
seems
that
seems
to
be
like
a
strong
push
in
the
community.
Right
now
is
to
to
just
use
that
just
detection
of
name
spaces
in
these
various
places
as
a
way
to
identify
this
stuff
yeah.
D
So
the
way
I
was
thinking
of
it
is
where
we've
got
here,
so
we
have
a
event.name
identifies
whether
it's
an
event
and
then
we
have
to
go
and
define
based
on
the
actual
value
of
that
event
name.
We
then
define
the
the
schema
in
terms
of
what
attributes
are
expected
for
that
event.
B
D
D
B
We
have
the
same
problem
with
span
names
today,
right
of
like
there
could
be
some
naming
convention
collision
there
in
practice,
it's
never
come
up
as
a
problem,
so
yeah
in
in
favor
of
just
continuing
with,
like,
like,
like
my
hope,
is
like
yes
to
just
continue
with
the
same
pattern
and
so
basically
have
one
place
in
the
spec
where
we're
defining
how
these
like
name
attributes,
are
like
supposed
to
work
for
like
event,
names
and
span
names,
and
it's
the
same
same
rules
for
everything
and
it
yeah.
B
A
Sure,
okay,
talk
to
you
later
yeah.