►
From YouTube: 2022-12-13 meeting
Description
cncf-opentelemetry meeting-2's Personal Meeting Room
A
B
D
B
Yeah,
but
no
it's
like
a
in
Southeast
Asian
cultures.
There
is
a
I
think
it's
originally
from
South
Korea,
there's
a
lot
of
like
isolation
for
lunch
or
whatever,
and
so,
if
you
like,
virtually
eat
lunch
with
people
who,
like
stream,
their
lunches
and
they
eat,
but
they
eat
like
ridiculously
large
portions.
B
You
know
what
we're
done
at
we're,
not
table
that
one.
It's
not!
Let's
not
Google
it
on
a
recordical.
B
A
D
It
was
an
eventful
specsig,
so
there's
a
little
bit
more
discussion
about
debug,
safe
mode
I
think
we
brought
this
up
a
little
while
ago
earlier
in
the
fall,
that's
when
it
was
opened.
It
was
if
you
go
back
in
the
Ruby
archives.
There
was
this
whole
safe
mode
idea
and
experiment
that
was
kind
of
like
abandoned
because
of
the
pain,
but
basically
it
all
kind
of
comes
down
to
Hotel
error
handling
where
the
yeah
I
guess.
D
The
Crux
of
the
problem
is
that
we
don't
want
hotel
sdks
to
raise
any
exceptions
like
that.
Your
application,
wouldn't
already
it's
like
tracing-
should
not
crash
your
app,
but
that
leads
us
to
this
problem
of
like
well.
How
do
how
do
you
surface
errors?
Because
there
are,
there
will
be
programming
errors,
Etc
and,
if
they're
all
silent,
it
makes
it
very
hard
to
hard.
D
So
we
ended
up
adding
like
this
error
Handler
a
long
time
ago,
which
we
have
in
in
in
Ruby
and
as
far
as
I
can
tell
that's
where
this
is
like
heading.
It's
like
you
can
just
implement
this
by
piping
errors
to
the
error
Handler
and
if
you
would
like
to
fail
fast,
just
raise
an
exception
in
the
error.
Handler
yourself.
So.
C
A
C
D
Yeah,
so
so
I
don't
see
this
being
like
a
big
big
change
that
anyone's
gonna
have
to
adopt.
There
might
be
like
some
rules
about
like
when
you
should
send
something
to
the
error,
Handler,
but
I
think
that's
probably
reasonable.
D
It
does
seem
to
be
a
problem
like
when,
when
there
are
problems,
people
trying
to
get
off
the
ground
and
the
the
application
is
silent,
so
having
a
little
bit
better
like
Diagnostics,
a
way
to
tap
into
that.
So
it's
always
useful.
D
Moving
on
this
thing
was
bike
shadowed
forever
because
it
looked
very
pythony
but
are
pythonic
there
you
go,
that's
the
the
adjective
I
believe,
but
yeah
I
think
they
were
saying
that
none
should
be
an
acceptable
environment,
variable
for
a
number
and
I
think
a
lot
of
people
had
problems
with
this
I
think
everybody
has
their
ways
to
Street
environment
variables
and
to
turn
them
into
the
right
type
and
I
think
this
was
one
that
probably
would
not
mesh
well
with
a
lot
of
them,
and
you
know
Peoria
is
like
why
don't
you
just
provide
another
number
that
can't
possibly
be
the
answer,
instead
of
not
like
negative
one
negative
17
whatever
like
for
for
different
variables,
there
can
be.
D
See
there
is
a
combined
sampling
and
message
instrument:
instrumentation
Sig,
there's
a
8.
Am
there
is
a
talk
about
sampling
and
span
links,
so
I
think.
D
Yeah
I
think
the
tldr
is
that
with
sampling
we
have
good
ways
or
reasonable
ways
to
ensure
that
you
get
like
a
complete
Trace.
D
D
So
I
think
they
have
some
proposals
on
how
to
make
this
work.
It
might
be
the
case
that
things
that
were
previously
unsampled
will
be
flipped
to
sampled,
but
I.
Think
the
the
teaser
was
come
to
this
meeting.
If
you
care
about
these
things-
and
we
have
a
proposal
I
think
so
if
anybody
is
interested
that
could
be
interesting.
D
Tristan
has
been
asking
some
questions
about
untraced,
which
is
our
helper.
There
are
some
similar
ones
around
JavaScript
has
one
that
is
contact
space,
but
he's
trying
to
figure
out
how
to
implement
this.
D
For
for
erlang
I
think
his
biggest
question
was
like,
should
it
be
part
of
the
API
or
part
of
the
SDK
who's
leaning
towards
SDK,
because
it's
usually
the
SDK
that
wants
to
like
turn
off
tracing
like
when
you're
exporting
spans
or
whatever,
like
you,
don't
want
to
create,
you
don't
want
to
create
an
HTTP
span
for
the
sdks
exports
or
or
other
such
things.
D
There
were
some
debates
saying
that
it
is
actually
useful
still
in
the
API,
so
I
know.
Writing.
Instrumentation
I
have
sometimes
used
these
things
in
in
at
the
API
level,
not
for
hotel
instrumentation,
but
for
other
things.
Just
because
you
I
don't
know
you,
you
have
an
instrumentation
that
wants
to
kind
of
like
override
another
instrumentation.
In
some
ways
you
could
kind
of
even
think
that
maybe
Faraday
might
want
to
do
this
or
something,
if
you're,
doubling
up
some
useless
fans
by
silencing
some
of
the
underlying
https
fans.
D
But
at
any
rate,
this
also
led
to
like
I,
think
Tristan's
gonna
come
up
with
a
proposal
to
try
to
unify
this
between
languages,
which
is
nice.
Then
the
discussion
led
to
like.
D
Should
this
be
an
Otep
or
just
a
PR,
and
then
there
was
an
acknowledgment
that
the
Otep
system
is
broken,
but
there's
a
lot
of
like
really
good
ideas,
lying
abandoned
in
the
oteps
repo,
and
there
was
at
least
a
a
bit
of
a
sidebar
talking
about
what
can
we
do
to
fix
the
Otep
process,
so
I
think
I?
Think
people
are
interested
in
fixing
the
Otep
process.
I.
Think
one
of
the
critiques
about
it
was
like
GitHub
and
GitHub
comments
might
not
be
serving
that
process
super
well,
but.
D
D
We've
seen
this
document
before
this
is
actually
a
revision,
though
so
this
is
like
V2
there's
more
information
in
here,
but
generally
the
idea
is
the
same.
There
will
be
some
working
groups
spun
up
for
each
one
of
these
topics.
D
D
I
thought
we
were
being
prudent
to
giving
ourselves
padding,
but
actually
what's
happening
is
that
each
one
of
these
things
is
a
three-quarter
project
and
they
overlap.
D
D
I
think
and
then
he
will
create
a
doodle
of
this,
so
you
can
see
the
overlapping
things.
It'll
look
it'll,
look
like
a
Trace,
so.
D
Context,
attributes
I
know
there
are
folks
on
the
call
who
have
been
very
interested
in
carry-ons
and
other
such
things,
basically
in
in
process
attribute
stapler
to
your
Telemetry
is
really
what
we're
talking
about
here
and
I.
Don't
know,
maybe
a
red
swing
line
attribute
in
process
stapler,
something
like
that
is
what
comes
to
mind
for
me,
anyways,
but
but
yeah.
This
is
one
of
these
otops.
That
is
actually
a
great
Otep.
D
That
I
was
looking
at,
and
this
thing
is
really
quite
well
written
and
long
and
thorough,
and
it
discusses
many
ways
to
basically
have
context
scoped
attributes
which
would
be
attributes.
You
stick
in
in
a
context
and
they
magically
appear
on
all
of
your
traces,
metrics
and
logs
from
there,
and
this
would
be
something
it
would
be
a
separate
system.
It
would
be
like
adjacent
to
what
we
currently
have.
D
C
D
Yeah,
so
people
acknowledge
that
this
has
been
like
a
regularly
requested
feature
and
people
have
been
trying
to
hack
around
it
in
a
bunch
of
various
ways,
but
it
guilty,
but
but
I
think
there
was
an
acknowledgment
that
this
needs
to
be
solved
once
and
for
all.
So
it
I
think
it
is.
It
is
something
that's
going
to
get
some
attention.
I
think
everybody
is
loaded
up
on
a
lot
of
stuff,
but
this
was
something
that
we
need
to
really
put
this
on
some
kind
of
priority
list
for
early
next
year.
D
Something
like
that
was
the
consensus.
D
And
then
we
quickly
breezed
through
some
of
these
final
issues.
Exponential
histogram
jackberg
did
some
performance
analysis,
the
Java
implementation
and
with
the
exponential
histogram,
you
have
a
scale
as
the
scale
becomes
positive
and
increases
in
magnitude
on
the
positive
scale.
D
He
did
notice
that
it
takes
more
computation
to
compute
the
bucket
boundaries.
So
one
thing
that
he
was
suggesting
was
to
happen
the
at
the
max
scale
by
a
configuration
option.
I
think
there
will
be
some
discussions
about
that
and
whether
it's
really
necessary
or
if
it's
yeah
as
it
is.
B
Easy
idea
to
cap
the
the
number
of
buckets
or
the
max
yeah,
okay,
so.
D
Is
that
actually
the
number
of
buckets
the
number
of
buckets
and
ends
up
getting
fixed
but
like,
as
the
scale
goes
up,
I
forget
what
this
actually
does
to
the
buckets
yeah
the
boundaries
change,
that's
kind
of
the
the
way
things
work
and
then
the
kind
of
equations
that
you
use
to
calculate
the
boundaries
become
more.
B
A
B
D
And
then
yeah,
very
briefly,
Jay
MCD
mentioned
that
there
are
some.
D
Yeah
there
are
some
issues
for
around
cardinality
how
to
how
to
drop
things.
When
you
drop
things,
what
do
you
send
to
acknowledge
kind
of
drops
Etc?
This
wasn't
really
gone
into
that
all
that
much
probably
something
we'll
care
about
a
little
bit
more
once
our
metrics
SDK
is
a
little
more
mature
and
this
other
one
is
this
up
metric,
which
has
been
talked
about
a
little
bit.
I.
D
Think
it's
an
otab,
but
this
would
be
a
way
to
to
kind
of
simulate
what
Prometheus
gets
because
Prometheus
scrapes
it
kind
of
knows
that
something's
up,
because
it
is
the
one
calling
out
to
the
service,
but
for
like
a
push
based
metric
system.
C
D
D
C
D
All
right
so
I
think
that
rounds
out
the
Tito
specsic
recap
and
Eric
launch
recap
with
ratings.
D
Anybody
have
any
questions.
Comments,
concerns
more
courses
to
talk
about.
A
D
C
D
So
this
is
a
very
nice
summary
and
a
very
nice
agenda.
I
will
point
out
that
it
is
in
the
template,
but
a
little
cut
and
paste
could
get
us
down
onto
our
actual
day.
Who
wrote
this?
C
C
One
two
three
there's
a
a
comment:
13
days
ago,
somebody
reporting
that
the
way
that
we
and
look
up
the
path
for
the
span
that
comes
out
of
the
request
breaks
their
stuff
because
the
they've
got
an
engine
attached
that
a
rails
engine
attached
that
is
like
a
a
fallback
catch
all
and
and
that
things
I'm
having
trouble
with
calling
rails
route.
What
it
is,
I
haven't
fully
digested
this
problem,
but
I
think
this
is
part
of
the
impetus
around
the
discussion
that
opened
about
having
rails
instrumentation,
wrap
active
support.
C
Notifications
subscription
that
yeah
active
support
notification
events:
you
subscribe
to
certain
named
events
and
we
can
translate
them
into
semantic
convention
spans
for
that.
C
I
think
I'm
interested
in
but
again
we've
had
problems
with
exceptions,
handling
Within
subscribers
and
and
all
that
I
know
that
would
help
some
of
my
customers
migrate
to
open
Telemetry.
If
say
the
in,
translating
an
active
support
notification
event
to
an
Hotel
semantic
conventions,
if
just
the
semantic
conventions
were
added
and
the
rails,
Fields
left
on
the
span
would
help
people
migrate
from.
C
Really
any
vendor
who
has
instrumentation
of
that
that
relies
on
active
support
notification
if,
if
we
do
this
and
turn
active
support
notification,
events
into
hotel,
semantically,
hotel
events,
but
with
all
of
the
other
rails
fields
on
it,
people's
existing
queries
will
work
in
their
system
while.
C
D
C
Think,
oh
and
I
think
that
that
would
be
a
workaround
for
this.
If
you
chose
to
use
the
no
I'll,
just
subscribe
to
stuff
rails
will
have
interpreted
the
rails
route.
D
Yeah
I
think
I
think
ultimately,
moving
towards
access
to
support
notifications
will
be
a
positive
in
in
many
ways,
I
think.
Originally
this
this
was
discussed
before
kicking
off
all
this
rails.
Instrumentation
I.
C
D
I
I
think
the
big
hold
up
was
like
they
worked
flawlessly,
except
for
in
the
exceptional
case.
Where
a
stands
didn't
get
ended,
then
you
end
up
with
Europe,
with
lingerings
fans,
potentially
like
a
broken
Trace
other
weird
things
so
I
think
yeah
out
of
caution.
We
want
more
of
the
wonky
patching
way
and
I
think
most
in
my
vendor
experience.
I
would
say
that
things
were
like
a
combo.
There
was
notifications
when
you
could,
but
then
there's
also
some
monkey
patching
when
you
had
to
which.
C
Well
and
I'll,
I'll
I
was
sold
on
the
monkey
patch
by
Robert,
who
did
the
implementation,
where
you
can
instrument
callbacks,
which.
A
D
No
we're
not
able
to
get
with
straight
notifications,
but
I
do
think
that
moving
towards,
like
a
notifications
system,
will
be
good
for
us
and
rails
and
like
adding
notifications
to
rails,
for
things
that
are
missing
would
be
good
for
us
and
rails
and.
C
Then
I
think
having
both
for
a
while,
wouldn't
be
awful
like.
If
you
want
the
low
level
you
can
use
the
monkey
patch
instrumentation.
If
you
want
to
just
subscribe
to
stuff,
that
was
in
my
experiment
with
instrumenting
Mastodon,
there
was
the
conflicts
that
I
brought
up
where
two
gems
that
are
monkey,
patching
active
record
conflict
and
you
get
a
stack
level
too
deep.
So
I
turned
off
the
patched
active
record
instrumentation
and
used
active
support.
C
Notifications
subscribe
to
the
active
record
events
and
get
good
enough
spans,
but
those
spans
don't
have
Hotel
fields
on
them
like
they
would.
It
would
be
perfectly
sufficient
if,
if
it,
if
it
had
the
Hotel
semantics
add-on.
C
I
bring
it
up
in
context
of
the
discussion,
that's
underway,
that's
at
the
bottom
of
that
the
Andrews
mentioned
of
the
migrate
rail
instrumentation.
D
A
D
Crazy
idea
to
fix
this
as
it
currently
exists,
without
yeah,
without
really
looking
into
this,
would
be
to
let
the
rails
router
do
its
thing
and
then
stash
that
information
somewhere
in
a
context
in.
D
Yeah
it
records
what
it
concluded
somewhere
and
then
we
could
pick
that
back
up,
but
I
think
you
know
all
these
things
are
usually
terrible
ideas
in
in
the
short
term.
They
always
work,
but
in
the
long
run
they
always
end
up
being
things.
You
regret
so.
E
No,
no
it's
okay,
I'm,
just
listening
I
was
just
thinking
like
it
was
going
to
expand
a
little
bit
on
that
little
illusion
there
at
the
bottom
of
hayward's
migrate
to
use
active
support.
E
Notifications
like
I,
have
it
in
my
head
that
we
should
do
away
with
all
the
monkey
patching
and
the
rails
instrumentation
ecosystem
that
we
have
I
think
before
kind
of,
like
I,
feel
like
I'm,
repeating
a
little
bit
of
things
that
everyone
said,
but,
like
the
active
support
notifications
were
not
I,
think
stable
enough
or
suitable
enough
for
our
needs,
but
as
far
as
I'm
aware,
they've
been
fixed
in
a
way.
That's
really
great,
so
I
I'd
like
to
see
the
future
iterations
of
all
the
rails.
E
Instrumentation
just
just
use
ASN
I
feel,
like
that'll,
put
us
in
a
really
good
position
to
work
with
the
rails,
maintainers
and
Community
to
add.
New
notification
hook
points.
So
if
we
want
things
like
callbacks,
if
we
want
instrument
callbacks,
we
could
do
that
in
a
very
formalized,
well-defined
way
that
a
rails
maintainer
says
is
the
right
way
to
do
it.
E
So,
instead
of
us
messing
around
like
a
lot
of
my
active
record
instrumentation
of
the
monkey
patching
since
the
rail
7
release,
I
have
very
little
confidence
in
it
like
it's
sporadic
and
it's
working
and
it's
it
was
not.
E
It
was
very
stable
for
six
I
guess,
but
nothing
else,
and
so,
like
my
my
entire
thinking
about
it,
has
completely
changed
but
like
even,
for
example,
like
the
action
pack
stuff
that
we're
looking
at
right
now,
I'm
looking
at
right
now,
there's
no
notifications
that
seem
to
give
us
what
we
want,
but
what
they
do
have
is
something
that
I
have
seen
people
ask
for
is
that
you
could
instrument
each
middleware
call,
so
you
get
the
full
call
stack.
E
The
middleware
I
think
there's
varying
degrees
of
utility
there,
but
I
have
seen
people
ask
for
it,
and
I
have
seen
it
done
in
a
lot
of
different
language
implementations,
and
so
there
must
be
something
to
it,
but
to
make
that
as
it
would
become
trivial
to
add
that
functionality
now
right,
it's
already
supported,
we
don't
have
to
guess
at
it.
We
don't
have
to
Monkey
patch.
Anything.
E
It's
just
rails
gives
us
a
way
to
do
it,
so
it's
I'm
not
I'm,
not
sure
if
I'm,
like
kind
of
sidetracking
the
conversation
but
I
would
really
love
to
whether
it
comes
from
an
internal
initiative
at
Shopify
or
something
that
happens
in
the
community,
I'd
like
to
effectively
blow
away
all
the
existing
instrumentation
and
rails
and
switch
it
all
to
active
support
notifications,
which
is
a
total
180
from
previous
conversations.
But
again
the
Crux
here
is
that
there's
confidence
in
it
now.
E
Again,
like
I
think
what
is
really
useful
and
I
think
this
is
a
point
that
Matt
actually
made
a
very
long
time
ago.
Is
that,
like
I,
think
it'd
be
easier
to
get
support
from
the
rails
Community.
If
we
use
those
notifications,
because
it's
like
trying
to
get
as
much
as
I
love,
open,
Telemetry,
I
still
think
getting
open
Telemetry
as
first
party
instrumentation
rails
would
be
a
very,
very
challenging
hurdle
and
not
that
we
shouldn't
work
towards
it.
E
C
I
don't
know
it's
like
I
feel
like
a
a
potential
future
that
opens
up.
Is
we
don't
have
to
convince
rails
to
adopt
open
to
them,
adopt
open
Telemetry
as
much
as
there's
a
component
that
you
can
a
config
component?
That
says,
where
would
you
like
to
send
your
otel
and
it
just
subscribes
to
whatever
events
rails,
instrumented
itself
with
and
then
routes.
B
B
During
the
seven,
whatever
seven
zero
X,
whatever
they
fixed,
a
bug,
Francis
has
more
context,
obviously
always
doesn't
even
need
to
be
said,
but
where
yeah
in
the
chain
of
notifications,
if
one
of
them
throws
an
error,
the
others
in
the
chain
don't
call
so
that
is,
you
know
like
a
deal
breaker
for
instrumentation.
We
can't
rely
on
it.
So
I
think
we'll
have
to
maintain
this.
B
Can
show
you
know,
options
config
is
Magic.
You
can
do
that.
I
agree
with
what
Robert's
saying
I,
also
I've
seen
so
there's
already
there's
some
context
of
I.
Think
someone
from
Century
wants
like
ask
for
additional
ASN
notifications
for
like
action,
cable
or
one
of
them.
One
of
the
whatever
rails
is
doing
these
days
with.
What
you
see
is
what
you
get.
C
B
It's
good
and
I
agree
and
I'm,
saying
there's
already
prior
context
and,
like
proof
of
the
Rails
Community
has
been
open
to
basically
some
vendor
coming
in,
be
like
hey
cool.
We
use
this,
we
use
ASN.
Can
you
add
one
more
ASN
notification,
which
is
effectively
like
a
no-op?
If
you're
not,
you
know,
subscribing
to
it,
so
it's
not
a
big
deal
and
they
were
like
sure
and
they
added
it,
and
it
was
a
pretty
quick.
Like
was
pretty
painless.
B
Tracing
yeah,
it's
crazy,
yeah,
cool,
yeah,
yeah,
so
I
think
that
is
all
good
stuff.
Maybe
we
have
a
call
out
around
the
the
before
the
Callback
stuff
to
be
like
hey,
look
like
if
you
want
to
measure
callbacks
either
one
we
could
work
Upstream
to
be
like
cool.
Can
you
add
notifications
to
be
inclusive
callbacks,
or
we
just
say
like
use
this
other
option?
If
you
want
to
use
callback.
C
I'm
I'm
game
to
be
a
part
of
that
since
well,
since
I'm
talking
about
a
lot
I,
don't
know
about
it,
it'll
happen
any
activity
before
the
holidays,
but
I
might,
in
my
idle
time,
do
a
little
like
all
right.
This
ASN
event
kind
of
looks
like
this
hotel
semantic
thing
and.
B
Am
curious
whether
we'll
have
the
like
semantic
conventions
are
pretty
can
be
a
little
onerous,
sometimes
with
regard
to
like
the
information
they
need
in
there
and
I'm
curious,
whether
we
will
have
it
all
in
the
ASN
notification.
I
think
we
want
to,
but,
like
we'll
see,
I
guess
wouldn't.
Surprise
me
if
there's
one
or
two
cases
where
it's
like,
we
don't
have
some
random
information
about
the
DB
on
these.
C
B
D
Yeah
I
think
all
this
is
kind
of
coming
together
at
at
a
pretty
good
time,
because
conventions
project,
so
as
those
things
kind
of
oh
to
try
to
beef
up
the
access,
support,
notifications
on
the
rail
side
and
missing
attributes
and
missing
events
to
the
point
about
having
to
maintain
multiple
versions
of
the
instrumentation
I
feel
like
that
will
probably
be
a
little
bit
of
a
pain.
We
do
want
stuff
to
work
for
older
versions
of
rails
and
active
support.
Notifications
work
reasonably
well
for
older
versions
of
rails.
D
D
That
what
you're
saying
yeah
monkey
patch
the
fix
into
like
rail,
6
or
rails
five
and
then
and
then
we
only
have
one
version
of
the
instrumentation
whatever
it
is.
Whatever
problem
is
existing
in
you
know
pre-rail
seven
actually
support
notifications.
D
C
There's
also
you're
getting
a
signal
when
your
traces
are
all
jacked
up.
Yes,
you
it's
hard
now
debug,
but
the
signal
is:
we've
got
another
active
support
subscriber
in
there
and.
D
We
can
explore
this
a
little
bit
more
well,
I
I,
think
if
we
don't
want
to
maintain
two
versions
over
of
rails
instrumentation,
we.
D
A
way
to
to
maintain
one,
probably
I,
wouldn't
rule
it
out,
at
least
from
the
beginning,
without
exploring
it
first
I.
E
Think
one
of
the
things
too,
that
could
work
to
our
benefit,
to
make
this
a
little
bit
easier.
Is
that
like
rails,
is
a
very
explicit
supported
version
life
cycle
and
as
supported
versions
age
out,
so
can
our
compatibility
with
other
stuff
like
I,
know
it's
nice
that
we
always
want
to
be
generous
with
all
of
that
but
like?
D
C
D
Also
spawn
a
business
for
some
enterprising
people
who
are
like
what,
if
we
just
allow
people
to
run
rails,
two
three
forever
with
security
patches
anyways.
Hopefully
my
guess
is
that
people
who
are
running
rails,
two
three-
are
probably
not
overlapping
with
Hotel
adoption
at
all.
You'd.
B
C
A
B
C
I
will
go
drop
some
words
on
that
discussion
to
say
that
we've
talked
about
it
in
there
fans.
D
I
did
have
one
mildly
burning.
Question
I
saw
a
comment
in
in
the
cncf
slack
about
a
Ruby,
SDK
and
rust,
but
and
say
what
it
seemed
like
something
might
exist.
Sdk.
E
Was
asking
I
can
talk?
I
can
talk
to
this.
If
you
guys
want,
we
like
a
trap,
player
kind
of
in
this
like
extended
like
HEC
days,
decompression
days
mode
and
Francis
since
long
before
the
open,
Telemetry,
Ruby
implementation
even
existed,
has
been
pining
over
this,
like
Ruby
into
systems,
level,
language
kind
of
implementation
and
so
we're.
Finally,
taking
the
time
to
do
it.
E
Shopify
has
adopted
rust
as
its
systems
language,
so
it
makes
sense
that
we
use
that
here
so
effectively
what
we're
a
lot
of
distractions,
but
that's
not
part
of
the
point
we're
supposed
to
be
focusing
over
over
the
last
week
and
this
week
on
basically
implementing
the
SDK
like
an
adapter
for
Ruby's
API
into
rust's
SDK,
with
the
intention
of
what
you
call
all
any
of
your
API
methods.
Like
start
span,
it
ends
up
calling
the
rest
start
span,
we're
using
some
some
crates
like
Magnus
and
RB
cysts.
E
So
these
provide
like
helper
functions
into
the
Ruby
C
API,
the
the
like
the
the
goal
here,
like
the
actual,
like
outcome
here,
isn't
like
just
because
the
ideas
we're
hoping
that
we
can
move
some
of
the
memory
pressure
off
of
Ruby
and
into
rust
and
then
potentially
get
some
CPU
gains.
E
If,
for
some
of
the
things
we
do
like
right
now
in
our
internal
production
deployment
for
a
lot
of
applications,
if
you
capture
Ruby,
VM
stats,
when
we're
starting
and
finishing
spans
every
time,
we
start
a
span,
we'll
actually
record
like
how
many
object
allocations.
The
current
GC
duration
and
we
close
this
band,
we
do
the
same
and
we
compute
the
Delta
and
so
that,
if
you're
running
in
a
single
thread,
you
have
fairly
high
levels
of
accuracy
of
how
many
allocations
happen
within
an
individual
span.
E
But
when
we
profile
this,
we
see
that,
in
the
context
of
like
Ruby
in
in
how
it
shows
up
on
our
profiling,
for
like
say
an
application,
a
lot
of
time
is
being
spent
there.
We
want
to
CPU
time
is
being
spent
doing
that
work.
So
every
time
we
start
a
spend.
E
And
then
like
the
really
like
grandiose
like
long-term
Visions
would
be
like
of
it.
I'll
be
done
like
ebpf,
but
this
is
very
much
like
a
stepping
stone
into
trying
something
interesting
and
seeing
if
we
can
squeeze
some
useful
performance
out
of
it.
It
also
has
the
added
benefit
that
we
wouldn't
use
the
Google
product
job
anymore,
which
is
everyone's
favorite
so
because,
like
that
definitely
hasn't
introduced
memory
leaks
for
us
ever
ever
so
we'd
be
able
to
get
away
from
things
like
that.
E
Libraries
that
are
have
historically
been
problematic
for
us
internally
as
a
dependency.
So
that's
what
it
is.
There's
a
branch
Francis
is
committing
code
to
it.
It's
SDK
underscore
rust,
I,
think
or
rest
underscore
SDK.
It
exists
in
our
main,
open
symmetry,
Ruby
repo
feel
free
to
look
at
it.
I,
don't
know
how
far
it'll
get,
but
it's
fun.
What.
E
Painful
ours,
like
that
I'm
sure
you
would
be
like
the
quarter,
one
not
controlled.
It's
just
a
branch.
Nice.
C
There's
been
a
it's
tickling,
a
memory
of
some
ruby
gems
that
had
optional
C
extensions,
where,
if
you
didn't
enable
or
or
if
for
some
reason
you
were
installing
the
gem
on
a
system
that
didn't
have
a
c
compiler
for
reasons
it
would,
you
would
just
do
the
thing
in
Ruby.
But
if
you
flip
the
switch
or
or
something
was
present,
it
would
then
compile
the
C
extension
and
then
use
it.
Is
that
the
pattern
that
might
come
out
of
this,
where.
E
E
Cool
yeah,
I
think
I
think
it's
cool,
there's
a
bunch
of
stuff
Happening
Here
with
it.
If
you
want
to
see
so
this
is
like
what
I
actually
linked
is
someone
wanting
to
merge
into
that
Branch?
So
there's
three
of
us
working
on
it
yeah
if
you
just
want
to
look
at
it.
Some
of
this
is
code.
E
That's
just
like
very
much
experimental,
so
the
Williams
contributed
to
the
repo
a
few
times
he
works
with
us
internally
and
he's
trying
to
get
like
the
export
pipeline
working
here
in
rustland
and
I.
Think
some
of
the
like
really
simple,
but
digestible
things
are
like.
If
you
look
at
what
file,
should
you
look
at?
No,
this
pier
is
not
it's
a
little
bit
more
convoluted.
If
we're
trying
to
get
ease
into
this,
you
know
what
I
actually
don't
really
know.
E
How
to
do
very
well
with
GitHub
is
find
the
compare
button
when
you're
looking
at
a
branch,
I
always
struggle
with
that
I.
A
C
E
C
Want
to
compare
it
to
Maine
right,
just
like
yeah
correct.
What's
your
branch,
if
you
go
to
that
Branch
wparon,
SDK,
rest.
C
The
in
the
information
about
the
it
says,
big,
open
status
and
then
wpr
wants
to
merge
five
right
below
the
title
of
the
pr
there's
the
branch
name.
That's.
E
The
support
I
want
to
look
at
just
the
one,
that's
never
mind,
I
think
I
found
it.
Apparently
you
just
click
on
sure.
E
So
you
can
see
kind
of
what
it
looks
like
so
this
is.
This
is
actually
defining
methods
on
this
span
class,
but
we're
actually
implementing
it
like
it's
actually
defining
a
class
in
Ruby
with
the
expected
SDK
namespace.
And
then
you
can
see
all
the
rest.
Implementations
of
things
like
set
attribute
or
ADD
attributes.
Sorry
I
have
a
phone
call.
I
can't
miss
out.
D
D
E
Yeah
I
don't
know
if
anyone's
interested
in
like
how
the
interop
works.
I
think
some
of
these
examples
are
pretty
good
because,
like
I'm
honestly
like
having
a
bit
of
trouble
going
from
the
the
loving
care
and
embrace
of
Ruby's
Rebel
to
rust
and
dealing
with
that
and
trying
to
figure
out
how
I
interact
with
a
ruby
time
object
in
Rust,
but
at
the
bottom,
you
can
see
that
in
it
and
it
is
pretty
explicit
right,
it's
like
you're,
defining
a
class
called
span.
E
These
are
things
it's
using
things
called
a
crit
called
Magnus,
which
adds
a
lot
of
helpers
for
interacting
with
Ruby
vieiras.
So
you
can
say:
okay,
I,
have
this,
this
class
called
span
and
I'm
going
to
Define
methods,
and
then
you
can
actually
see
the
methods
it's
defining
and
the
implementations
of
them,
which
is
pretty
cool.
So
it's
like
you
can
write
your
available
Ruby
code
in
Rust
and
then,
when
you
actually
invoke
it
from
Ruby,
it's
going
to
call
down
into
rest.
E
So
it's
a
like
all
things
considered:
it's
fairly
ergonomic
but
again,
there's
like
a
pretty
steep
learning
curve
going
from
Ruby's
very
permissive
type,
checking
to
rusts,
not
so
permissive
type,
checking,
there's
yeah
I,
don't
know
I
I'm,
not
really
in
a
good
position
to
like
give
this
like
full,
like
Whirlwind
Whirlwind
tour.
E
But
if
you
are
curious,
if
you
are
interested
in
it,
we're
gonna
keep
working
against
this
Branch
I,
don't
know
what
the
life
cycle
of
this
work
will
be
and
where
it'll
ultimately
live,
but
we're
just
doing
it
here
for
now,
because
it's
convenient
and
again
it
allows
things
like
this
to
happen.
We're
gonna
ask
questions
and
be
interested
in
it
and
I
think
that's
useful
for
the
community
still.
D
Yeah,
no
I
I
think
it's
a
super
awesome.
It's
it's
definitely
something
that
that
I've
been
curious
and
interested
in
so
I'll
kind
of
be
watching
from
the
sidelines
jealously,
but.
E
If
you
pull
the
work
it
it's,
this
Magnus
crate
I
believe
is
the
one
that's
doing
it.
It's
all
embedded
in
The,
Rake
task
so
like
you
like
you,
do
have
to
have
like
a
rest
run
time
available.
E
But
when
you're
doing
things,
it's
not
like
you're,
switching
back
and
forth
between
rest
building,
your
rust
files
and
you're
running
your
commands.
It's
just
bundle,
exact
rate
and
it'll.
Do
the
things
for
you,
which
is
again
great
so
like
there
are
considering
how
early
on
I
think
this
is,
and
it's
kind
of
it's
It's
Horizon.
It's
like
there's
a
lot
of
ergonomics
already,
which
is
cool
but
yeah.
We
haven't
gotten
any
benchmarks,
yet
we
don't
have
any
real
sense
of
like
the
performance
impact
of
this.
E
We
don't
know
if
this
is
really
going
to
be
like
yeah.
This
made
things
a
lot
better,
but
we're
we're
hoping
to
put
in
the
effort
here
so
that
we
can
answer
that
question
with
like
some
some
level
of
confidence
and
the
reality
is
like
it's
not
until
we
hit
like
a
real
Production
Service
till
we
will
actually
see
if
this
thing
is
useful,
like
a
synthetic
little
micro
benchmarks,
never
really
tell
the
true
story:
we've
learned
that
time
and
time
again
we're
all
working
on
this
stuff.
So.
D
Yeah
one
one
question:
I
I
can
see
that
a
knit
is
kind
of
the
glue
where
you're,
defining
your
your
Ruby
class
and
you're
kind
of
mapping.
These
Ruby
methods
to
your
rust
versions.
Here,
which
are
these
you
mentioned,
that
you
were
kind
of
delegating
off
to
the
Hotel
rust
SDK.
Is
that
actually
happening
here
or
is
that.
E
Yes,
if
you
look
at
the
top
of
the
file
I
believe
we
are
pulling
in
use,
open,
Telemetry,
globals,
block
box
span
box
span,
I
believe
is
extending
the
life
cycle
like
it's.
It's
putting
it
on
the
Heap.
E
I
can't
get
more
detail
than
that,
but
it
is
actually
when
we
create
a
new
span,
we're
creating
a
rust
boxed
like
open
photography,
rust
box
fan
same
thing
with
the
the
Tracer
provider
and
the
Tracer
we're
adding
like
it's
very
much
think
of
it
as
like
this
glue
layer
between
the
API
and
the
Russ
SDK,
so
we're
defining
movie
methods
available
in
Ruby
that
are
effectively
calling
down
into
the
rest
SDK.
E
E
Is
it
et
cetera,
et
cetera,
and
then
it's
creating
that
rust
span
and
when
we
finish
it
it'll
finish
the
rust
span
and
so
effectively
in
rubyline
you're,
just
holding
this
reference
to
the
rust
span
throughout
all
of
it,
and
you
still
have
all
the
same
methods
available.
So
when
you
pass
in
like
add,
if
you
want
to
add
attributes,
they
need
to
get
kind
of
mutated
into
rust,
compatible
context.
E
So,
like
again,
we
aren't
sure
how
much
performance
savings
we're
going
to
get
out
of
this,
but
we
think
there's
room
there
because,
like
even
when,
like
we
have
to
think
of
like
the
cost
of
when
we,
our
export
pipeline
is
probably
non-trivial.
We
do
copies
of
everything
like
when
you
go
through
your
spam
processing
Pipeline,
and
you
have
hit
your
your
finish.
You're
going
to
spend
data
so
you're
making
a
copy
of
the
entire
span
anyways
and
then
it
gets
serialized
to
whatever
your
export
format
is
so
and
I
guess.
E
This
is
another
thing
we
saw
when
we
were.
We
did
just
like
a
random
profile.
I,
don't
I
don't
know
if
these
are
like
super
definitive
findings,
because
it
was
just
like
a
single
uninteresting
profile,
but
there
is
a
significant
in
the
context
of
open
Telemetry
like
just
focusing
on
the
lines
of
open
Telemetry
in
that
profile.
E
E
That's
another
place
where,
like
you
know
how,
if
the
unfinished
it's
like,
are
these
attributes
valid?
Is
it
like
a
modular
et
cetera,
et
cetera
there
there's
a
bit
of
CPU
in
the
context
of
open
television,
not
the
entire
request,
obviously,
but
so
like
those
are
things
that
you
would
potentially
get
savings
on
right
because
the
for
us,
strict
typing,
we
don't
have
to
do
that.
They
are
valid.
We
know
they're
valid,
they
have
to
be
valid,
otherwise
we
don't
have
them
right.
The
serialization
costs
when
you
go
exporting.
E
D
Cool
yeah
awesome
to
see
this
happening,
I
think
if
nothing
else,
it
will
at
least
validate
that
that
the
API
design
is
sufficiently
decoupled
from
the
SDK
that
you
can
kind
of
plug
this
into
another
implementation,
which
I
think
is.
D
It
was
the
goal
of
the
project,
but
there's
always
until
you've
actually
tried
to
try
an
implementation.
You
don't
actually
know
so
I
think
that'll
be
a
good
validation
and
then
just
yeah.
The
the
actual
results
of
the
experiment,
I
think,
will
be
interesting
as
well.
Yeah.
E
E
I.
Definitely
again,
this
has
been
very
tricky.
I
got
very
frustrating
trying
to
convert,
trying
to
manipulate
a
ruby
time
object
in
Rust.
It
is
about
as
fun
as
it
sounds.
E
E
Is
the
worst
and
unfortunately,
we
can't
even
like
really
punt
at
that
farm,
because
the
span
API
obviously
accepts
start
timestamp
on
creation.
So
if
we
want
to
like
support
it,
we
have
to
deal
with
that.
I
mean
we
can
probably
punt
it
for
a
while
and
just
you
know,
do
what
we're
doing
and
just
set
a
default.
Describing
now.
C
Well,
somebody
can't
manipulate
it
after
it's
set.
So
if,
in
the
API
layer
we
like
okay
I
see
that
that's
a
ruby
time,
I'm
gonna
cast
it
to
something
else,
and
then
from
there
on
it's
something
else.
We.
E
Talked
about
that
I
did
one
of
the
really
hacky
things
that
it
didn't.
I
didn't
push
it
up,
because
it's
just
dumb,
but
you
can
from
this
Magnus
crate.
You
can
just
run
Ruby
code.
So
I
was
like
I
got
a
Time
object,
I'm
just
gonna
email,
some
Ruby
in
line
here
and
do
what
I
need,
but
again.
E
Exactly
nothing
so
yeah
I
know
we're
over
again
I.
Think.
What's
fun,
though
some
sort
of
conclusion
with
this
work
I'll
try
to
put
together
some
findings
and
share
with
the
group,
because
I
think
people
seem
interested
and
it's
fun.
D
Cool
awesome
thanks
thanks
for
the
info
and
the
tour
and
interesting
to
see
what
this
heads.