►
From YouTube: 2020-07-28 .NET SIG
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
B
D
A
A
Yeah,
that
means
someone
got
to
take
the
manual
work
to
write
some
script,
so
it
will
be
easier
for
the
others,
and
I
I
think
we
probably
need
to
have
a
a
simple
document
similar
like
how
open
telemetry
python
is
doing
just
to
document.
What
like,
what's
the
process
for
people
to
do
a
release
yeah.
I
have
like
some.
D
Basic
stuff
ready
here,
it's
just
that
I
never
put
it
right.
This
is
a
step
which
I
follow
to
release
it,
like
tagging.
Submitting
apr
then
kicking
off
this
and
uploading
it
manually
to
nougat.
So
this
is
what
I
documented,
but
yeah.
As
you
said,
we
can
put
a
note
saying
this
is
the
steps
and
then
because
no
one
can
actually
execute
it,
because
they
don't
have
the
key
yeah
and
that's
that
yeah
yeah,
that's
by
design
yeah
and
if
you.
D
Do
yeah
I
verified,
like
micro,
also
got
I
had
been
accessed
to
then
you
get
over
yeah.
We
should
have.
A
And
one
thing
I
was
curious,
so
we
still
need
the
the
various
studio
like
the
devops
pipeline
or
it's
something.
D
So
we
still
need
to
do
one
more.
What
line
of
four,
which
is
to
ensure
that
the
secret
is
stored
in
the
github
itself,
the
token
which
we
need
to
upload
to
my
get
so
right
now
it
is
stored
in
the
azure
devops,
but
there
is
no
reason
to
keep
it
like.
We
should
be
able
to
store
the
secret
in
github
itself
and
have
it
totally
accessible
to
maintenance,
okay,
yeah.
It
should
be
mobile.
Now
we
don't.
D
I
mean
it's
just
that
we
need
to
find
some
time
to
make
that
happen,
but
no
technical
issues
all
right.
I
think
we
can
start
yeah
if
you
can
put
your
names
here,
that
you
can
create
I'll
start
with
mine.
D
D
The
the
net
version
which
we
depend
on
is
also
on
nougat,
which
is
preview
seven
so,
and
the
dots
are
also
ready.
So
anyone
can
go
ahead
and
try
it
out
and
let
us
know
if
it
actually
works,
it
should
work
but
yeah.
We
want
to
really
know
feedback
on
what
are
broken
and
any
bugs
which
we
discover
it's
the
first
official
release.
So
we
we
know
there
are
like
things
which
are
still
missing
from
the
beta
release,
but
we
let
us
sit
in
the
next
release.
D
So
that
brings
us
to
the
topic
of
when
is
the
next
beta.
So
I'm
calling
it
as
0.5
like
logically
following
the
same
0.5
beta,
and
I
think
we
would
have
0.6.7
all
the
way
up
to
1.0
in
november
december
time
frame
when
we
remove
the
beta
tag
when
we
are
at
1.0.
D
So
my
current
estimate
is
will
release
another
another
beta
in
approximately
one
month.
The
biggest
blocker
is
we're
going
to
update
to
dotnet
preview
8.
The
diagnostic.
D
D
D
So
while
we
are
on
the
same
topic,
I
have
put
like
these
are
the
main
goals
which
we
want
to
achieve
for
beta.
So,
like
number
one
thing
is
we
want
to
update
to
the
newest
diagnostic
source
package
from
dot
net
feed.
So
I
already
started
on
that
and
this
contained
like
this
preview
8,
which
contains
all
the
changes
which
open
telemetry
ask
for
sampling
changes
and
supporting
for
string
and
other
types
for
tag
values
we
currently
have
string
and
string
and
few
smaller
changes
as
part
of
that
as
well.
D
So
this
is
a
number
one
priority
and
I
currently,
I
don't
think
I
created
an
issue.
I
just
started
working
on
it,
but
I'll
create
an
issue
tag
it
for
0.5,
milestone
and
assign
myself
and
submit
apr,
probably
tomorrow
or
maybe
end
of
day
today,
depending
on
how
much
progress
it
makes,
but
that
I
said
I
would
like
to
call
the
create
a
epic
item
called
quality
and
puff
drive,
because
we've
been
letting
prs
merge
with
open
questions,
because
our
primary
goal
was
to
make
progress
and
give
feedback
to
dotnet.
D
D
Last
week
we
have
like
most
of
the
places
we
have
already
created,
like
to-do's
in
the
core
itself,
so
it
should
be
straightforward
to
just
do
a
blind
search
for
to-do's
and
look
at
them
understand
them
see
if
it
still
makes
sense
or
or
actually
make
the
actual
fix,
but
some
places
we
did
not
have
mentioned
like
to
do
it's
it's
known
that
things
are
not
good,
so
the
actual
process
would
be
to
review
the
entire
code
to
make
sure
any
temporary
things
which
we
did
to
make
progress
are
revisited.
D
We
need
to
start
creating
issues
and
tag
them
for
either
0.5
or
the
beta
after
that.
So
that's
the
main
goal
and
while
doing
that
yeah,
we
need
to
address
performance
as
well,
because
it
may
be
okay,
it's
just
said
we
don't
really
know
unless
we
actually
start
measuring
it.
D
We
probably
also
have
to
make
the
benchmarking
as
part
of
ca,
build
it's
not
part
of
the
ca,
so
anyone
can
just
run
it
locally,
but
it's
not
part
of
the
ca
so
we'll
see
if
we
can
similar
to
code
coverage
being
posted
as
a
comment
to
every
pr
if
we
can
make
the
puff
numbers
also
part
of
like
every
pr.
That
would
be
great,
but
that's
not
high
priority,
but
if
we
can
make
that
happen,
that
would
be
good
I'll
see
if
we
have
some
resources
to
make
that
happen.
D
That
is
said.
We
have
somewhat
to
do
in
sampling.
We
are
out
of
complaints
with
the
spec
and
we
also
wanted
to
wait
for
preview
aid,
so
this
should
be
fixed
and
if
issue
is
already
created,
I
think
and
raj
from
microsoft
is
saying.
Currently
next
is
propagators.
This
was
like
a
major
slip
from
the
original
beta
schedule.
It
was
tracked
as
part
of
the
beta,
but
we
did
not
have
it
like.
We
do
not
have
global
propagators
or
composite
propagators
which
are
required
for
from
the
spec.
D
D
So
we
want
to
review
and
make
sure
all
the
public
api
still
makes
sense
and
want
to
make
some
of
them
as
internal
if
it
doesn't
make
sense
to
be
a
part
of
the
public
api,
because
we
want
to
be
very
careful
after
the
next
beta
about
breaking
the
api.
The
next
beta
will
definitely
have
breaking
changes
like
between
0.4
and
0.5.
D
There
will
be
breaking
change
for
sure,
but
that's
unavoidable,
but
after
that
we
would
get
more
and
more
conscious
about
breaking
the
api
so
to
enable
us
achieve
that
goal,
we
need
the
api
being
automatically
generated.
So
whenever
you
make
any
changes,
you'll
be
forced
to
think
okay,
this
is
a
public
api
change
and
even
the
pr
reviewers
can
see
it
instantly.
D
So
that's
one
another
goal
and
alan
already
started
working
on
end-to-end
examples,
so
we
hope
this
should
be
good
enough
chunk
of
items
to
release
the
next
part
of
the
beta,
but
of
the
next
meter.
D
So
preview
8
is
currently
tagged
from
dot
net
us
august
18,
so
it's
probably
within
one
or
two
days
after
that,
so
we
can
to
be
on
the
same
side.
Maybe
we
can
call
our
beta
would
happen
like
the
week
after
august
18..
So
we
know
we.
A
D
F
A
Started
cleaning
up
the
issue
and
created
the
this
like.
I
want
us
to
get
more
structured,
so
I
I
start
to
like
create
this
and
I
think,
moving
forward.
If
we
have
like
items
planned
for
a
particular
release,
we
need
to
clarify
what
we're
going
to
achieve
and
we
set
the
target
date
and
no
matter
where
we're
actually
behind
that
date.
D
This
one,
let's
put
three
or
four
days
or
let's
make
it
the
monday
after
dot
net
5,
is
coming
so
I'll,
find
the
exact
date
and
update
the
day
to
match
like
ad.
Is
here
it's
like
just
like
30
seconds.
So
let's
say
18th
is
when
dotnet
is
coming
so
yeah.
We
can
do
like
like
the
monday.
After
so
24
would
be
to
release,
it
will
have
new
features
yeah.
D
This
should
be
it,
and
this
one
ga
is
marked.
I
don't
think
we
need
to
touch
this
one,
but
let's
create
like
point
six
and
point
seven
sometime
when
we
are
reaching
closer
to
beta
two.
So
any
issues
which
we
don't
plan
to
tackle
at
beta2
would
be
handled
in
0.64.7.
D
Yeah
we
will
put
like
the
absolute
minimum,
so
let
me
do
that
homework.
I
will
create
issues
and
mark
them
as
like
must
for
beta
or
because
this
is
like
fairly
open.
I
don't
have
the
exact
list
so
some
of
them.
I
don't
really
know
whether
we
will
cover
but
everything
else.
This
is
absolute
necessary.
We
want
to
try
the
preview
as
soon
as
possible
and
like
everything
else
can
be
delayed.
There
is.
There
is
no
reason
to
delay
beta
the
next
beta,
because
we
didn't
finish
examples
or
propagators
or
something
yeah.
A
I
agree
so
in
the
issues
I
have
created,
the
the
tags
following
the
overall
like
the
open,
telemetry,
spike
and
other
repos
approach.
So
we
should
see
the
priority
one
like
priority:
zero
one
and
two-
and
I
put
some
clarification-
want
to
get
some
feedback
so
for
priority
one.
That
means
we'd
rather
delay
the
next
release.
If
we
cannot
finish
the
p1
item
and
for
p0.
This
is
like
like
stop
bleeding
issue
freedom
for
security
or
someone
like
attack
our
report
and
put
some
credential
there.
D
Like
in
the
previous
list,
if
I
put
something
as
p2
and
if
it's
not
done
by
beta,
we
still
release
the
beta
and
just
move
the
issue
to
the
next
milestone.
A
A
Yeah,
okay:
I
hope
that
that
can
help
us
to
get
clarification
here
and
their
debates
on
the
open,
telemetry's
background.
However,
we
need
p2
or
p3
and
I
think
it's
idk
for
now.
I
think
p3
is
going
to
give
us
confusion,
so
probably
not
right
now,
but
if
we
see
the
need,
we
should
have
a
talk.
Okay,.
D
Makes
sense
with
that
in
mind,
do
we
still
need
like
release
record
for
ga,
because
if
we
create
an
item
tag
it
for
1.0
and
make
it
p1,
it
automatically
implies,
it
is
really.
It
is
required
for
g.
A
Right
or
exactly
no,
I
think
it
has
a
different
purpose
according
to
the
spec,
so
this
for
ga.
That
means
we
got
to
do
that
anyways
before
ga,
but
we
could
do
that
earlier
or
later
it's
up
to
us.
Okay,.
F
F
About
how
this
aligns
I've
been
a
little
bit
confused
at
times
about
how
the
the
beta
versions
map
to
the
overarching
objectives,
like
from
the
specification
standpoint,
so
like
o50
maps,
to
like
a
specific
set
of
requirements
for
the
specs
correct.
A
Yeah,
I
mean
all
right,
please.
No.
This
is
different
from
my
understanding,
so
initially,
open
telemetry
has
the
very
first
beta
release,
which
is
0.3
and
at
that
time,
when
the
isdk
got
released,
it
also
has
0.3.
That
means
the
sdk
meet
with
the
the
open
telemetry
is
back
at
that
moment.
However,
after
0.3
the
spike
has
made
dramatic
changes,
and
that
means,
if
you
want
to
release
0.3,
you
have
to
look
at
old
scheme
and
do
some
strong
way
work
and
we
believe
it
doesn't
make
sense
for
donald
trump.
A
A
D
D
Okay
yeah
great!
Thank
you
for
that
clarification,
and
even
in
the
project
status
like
after
0.3,
it's
it's
somewhat
like
open
text,
additional
beta
releases,
so
only
ga
is
the
next.
So
we
have
that
flexibility
even
from
overall
open
element
like
different
languages,
can
have
any
number
of
releases
in
between
point
three
and
point,
one
which
may
or
may
not
even
match
to
the
exact
spec
portion.
B
And
one
thing
and
and
I'll
work
on
that
and
I
will
not
put
as
a
milestone
for
the
beta,
but
certainly
for
rga,
I
update
for
the
autop
exporter
because
the
proto
has
been
updated
since
the
last
time.
We
changed
that
I
I'll
do
a
pr
probably
next
week
for
that.
D
Yeah
thanks
for
that
yep
all
right,
going
back
to
the
next
item
to
open
questions,
so
I
promised
last
week
that
we'll
do
a
quick
five-minute
tutorial
on
using
activity,
source
and
activity.
Since
we
don't
have
a
lot
of
other
questions,
I
think
I
can
go
ahead
and
do
it
right
now.
It
should
not
be
an
open
elementary
tutorial.
It
just
shows
how
to
use
activity
and
activities
and
compare
the
legacy
way
in
a
new
way.
D
I
can
stop
me
if
I'm
exceeding
like
five
to
seven
minutes,
but
I
try
to
be
as
quick
as
possible,
so
you
can
still
see
my
visual
studio
right,
yeah,
okay,
yeah,
so
I
have
created
a
console
application.
It's
targeting.net
core,
app
3.1,
it
doesn't
have
to
be.
It
can
be
any
dotnet,
supported.net
versions.
The
key
thing
here
is
include
the
diagnostic
source
version,
previous.
Whatever
is
the
latest
available
from
you
get,
because
this
is
where
the
changes
which
I
or
the
things
which
I'm
about
to
show
are
applicable.
D
If
you
install
a
stable
version
of
diagnostic
source,
the
things
which
I'm
about
to
show
will
not
even
be
part
of
it.
So
if
you
are
following
that
tutorial
just
make
sure
you
install
the
latest
version
of
diagnostic
source,
the
latest
pre-release
version
of
diagnostic
source
from
you
get,
and
this
is
a
console
app
just
to
make
things
really
easy.
D
So
I
have
the
code
written
already
already,
but
I'll
just
walk
through
to
two
chunks
of
code.
The
first
one
shows:
how
do
you
create
or
what
is
the
new
recommended
way
of
dealing
with
activity
in
the
new
way
and
the
recommended
ways
to
use
an
activity
source
to
create
an
activity,
so
the
steps
involved?
Are
you
actually
create
an
activity
source?
First
I
mean
this
is
just
for
demo.
You
don't
actually
create
activity
source
repeatedly,
you
probably
create
it
in
a
static
variable
and
reuse
it
throughout
your
application,
but
just
for
demonstrating
the
concept.
D
The
idea
is
you
create
an
activity
source
and
you
give
it
a
name.
There
is
no
requirement
for
the
name.
It
can
be
anything
including
string.mt,
but
the
guideline
would
be
to
use
the
company
name,
slash
product
name
like
something
like
namespace,
so
that
it
won't
collate
with
any
other
activity
sources,
and
second,
is
once
you
have
the
source
you
actually
create
and
start
activity
in
one
shot.
There
is
no
api
to
create
the
activity
and
have
it
not
started
it's
simply.
There
is
no
option
to
do
that.
D
We
started
and
it
at
that
stage.
Activity
itself
is
created
and
started,
and
this
has
many
overlords,
I'm
showing
the
absolute
symbol,
one
which
takes
the
name,
but
you
can
pass
parent
context
or
initial
set
of
tags
or
activity
links
or
activity
kind.
As
extra
parameters
and
next
line.
Is
you
enrich
the
activity
by
putting
tags?
D
So
here
the
important
thing
to
notice
here
is
the
null
check,
because
if
there
are
no
active
listeners,
the
activity
will
not
end
up
being
created,
so
you'll
have
to
do
null
check
to
make
sure
you
don't
end
up
with
no
reference
exceptions
and
like
once
you're
done
with
using
the
activity.
You
call
stop
on
it.
D
Part
of
the
official
open
elementary
specs-
it's
not
linked
to
from
the
dot
net
repo,
but
yeah
that
one
one
thing.
G
That
I
would
encourage
you
to
consider
in
samples
like
this.
I
mean
it's
up
to
you,
just
as
a
consideration
is
not
using
var.
Like
this,
I
mean
it's
easier
to
write,
but
when
you're
actually
demonstrating
somebody,
so
they
understand
this
and
they're
just
learning
about
it,
then
actually
calling
out
the
type.
D
Is
very
yeah,
it
would
be
I'll
stick
with
whatever
we
have
for
dotnet
guidance
already,
because
I
don't
want
to
change
if
the
pattern
is
already
to
use
what,
but
the
final
resting
place
for
this
document
will
not
be
open
element.
It
will
be
in
the
dotnet
runtime
repo,
so
we'll
stick
with
whatever
is
dot
net
runtime
is
already
following
for
open,
telemetry
examples.
I
have
to
check
whether
we
are
using
this
pattern
or
not,
but
yeah.
G
I
mean
I
I
I
don't
mention
just
when
I
read
this,
I'm
like
okay.
Is
it
still
activity
or
is
it
something
else
so
var
can
be
like
it's
great
for
writing
code
that
you
read
yourself,
but
these
explanations
are.
A
Oh
yeah,
I
I
think
if
greg
want
to
talk
about
the
wire
we
can,
we
can
spend
more
time
here.
I
have
a.
I
have
a
different
question.
A
I
think
there
are
different
kinds
of
developers
where
some
of
them
like
me,
I
prefer
hungarian
naming
convention
and
always
be
specific
and
on
the
other
side,
that
people
prefer
like
very
flexible
javascript
style.
So
this
is
something
we
should
debate
on
the
tr.
So
my
question
is
today:
we
have
a
like
get
started.
Five
minutes
document
in
open
telemetry
is
part
of
the
beta
release.
A
There
are
two
caveats
number
one
is.
It
is
just
on
traces.
It
has
nothing
about
like
how
you
probably
get
contacts.
How
do
you
like
handle
metrics?
It's
just
like
the
basic
tracing
scenario
and
the
second
one
is
this
one
is
targeting
the
developer
that
works
on
the
application
integration,
so
it
doesn't
cover
any
aspect
from
hey,
I'm
a
newcomer
to
open
telemetry,
and
I
have
a
library
that
I
want
to
instrument,
I'm
not
doing
any
like
application
integration.
So
I
I
don't
care
about
exposure
like
those
things.
A
So
do
you
think
it
makes
sense
for
us
to
have
separate
document
telling
people
hey
if
you're
working
on
an
application,
you
want
to
gather
telemetry
data
and
send
them
somewhere.
This
is
the
five
minutes
tutorial
for
you.
If
you're
a
developer,
volcano
library
or
your
developer,
working
on
contributing
a
package
for
open
telemetry,
then
there
should
be
a
separate
tutorial
or
that's
too
much.
D
I
mean
I
personally
like
separate
tutorials
for
each
purposes,
because
if
you
are
a
contributor
who
wants
to
write
an
exporter,
let's
say
you
are
an
apm
vendor.
They
don't
really
get
anything
from
this.
They
need
like
something
else.
So
my
personal
take
is
yeah.
We
should
have
like
getting
started
for
each
of
these
categories,
which
we
just
mentioned,
yeah
just
trying
to
instrument
folks
who
are
doing
application,
and
then
people
who
want
to
enrich
or
contribute
to
the
open,
telemetry
itself
by
writing
their
own
exporter
or
sampler,
or
something
else.
A
Yeah,
I'm
happy
to
work
on
the
the
structure
of
this
and
I've
seen
that
in
the
python
project.
I've
done
thing
before
so
I
want
to
gather
feedback
here
quickly
like
what
are
the
getting
started
document
that
people
have
in
their
mind.
Besides
this,
I
think
there
should
be.
Can
we
go
back
to
the
meeting
notes
and
I
want
to
put
something
there
so
number
one
thing
is
get
started
on
metrics
number.
Two
thing
is
you
want
to
get
started
as
a
library
developer,
you
don't
do
any
integration,
you,
don't
you
don't
send
telemetry
data.
A
G
You
named
three
things,
but
those
were
for
it.
So
there's
a
writing.
A
library,
then
writing
an
application
and
that
kind
of
has
two
things
right:
exporter
and
custom
spans
right
and
then
you
could
choose
this
one
or
two,
but
the
two
sub
things
and
then
the
dimensions.
A
Yeah
yeah,
let
me
put
something
in
the
meeting
notes
and
I
want
to
collect
ideas
from
people
like.
Are
we
making
something?
Or
you
think
they
have
different
party,
that
we
should
focus
on
something
first
before
the
others.
D
H
Hi,
this
is
sandra
from
aws
we're
actually
newcomers
in
this
circle,
so
this
is
kind
of
a
good
segue
kind
of
injection.
For
me.
So
on
the
line,
I
have
two
of
my
uh.net
developers
who
want
to
contribute
and
we're
wondering
the
state
of
the
beta
and
if
you
guys
have
all
the
handlers
to
be
able
to
take
in
a
new
contributor
to
write
our
own
x-ray
tracer
explorer.
Are
we
at
a
good
spot
for
that?
H
D
Okay,
let
me
come
back
to
it
towards
the
end,
because,
let's
finish
the
tutorial
first
and
then
come
back,
because
I
just
realized
that
there
are
several
new
members,
so
we'll
go
around
them
once
and
then
get
back
to
the
specific
questions.
D
That's
okay
with
everyone.
Okay,
so
yeah
really
already
put
this
one.
So
let
me
go
back
to
the
tutorial,
so
I
was
just
showing.
How
do
you
create
an
activity
using
the
new
api,
which
I
mean
this
is
purely.net.
There
is
no
open
elementary
here
involved
at
all,
so
we
just
covered
this
section
and
the
next
section
is
just
showing
how
people
used
to
create
activity,
I'm
calling
it
legacy.
So
basically
you
create
activity
directly.
D
There
is
no
activity
source
involved,
you
create
activity,
then
you
start
it
then
again,
you
can
enrich
it
any
way
you
want.
Then
you
stop
it.
So
we
still
have
these
two
supported
way,
even
though
the
second
one
is
considered
like
somewhat
legacy
and
b
would
be
encouraging
usage
to
move
to
this
approach.
So
this
just
shows:
how
do
you
produce
activity
so
the
next?
I
would
show
how
what
are
the
things
which
dot
net
provides
to.
G
Subscribe
in
a
tutorial
in
the
context
of
legacy,
I
think
you
would
also
mention
diagnostic
source,
because
otherwise
a
person
who
doesn't
have
context
on
all
of
this,
they
will
discover
the
talks
that
say
you
shouldn't
be
creating
activities
directly.
Instead,
you
should
be
using
diagnostic
source,
they
will.
They
will
just
search
on
google
for
related
things
and
they
will
quickly
discover
those
dogs.
D
I
don't
really
know
the
answer,
because
if
I
were
to
talk
about
diagnostic
source,
then
this
won't
be
a
10
minute
thing.
This
will
probably
go
for
30
plus
million,
so
I
want
to
keep
it
like
absolutely
just
focus
on
the
activity
part.
But
what
greg
said
is
absolutely
correct.
The
current
documentation
in
dot
net
front
end
report
doesn't
even
recommend
this.
It
recommends
one
to
use
diagnostic
source
dot
start
activity
which,
apart
from
starting
activity,
also
files
of
a
diagnostic
event
and
the
listening
is.
G
D
G
Completed
that
is
written
up
if
it
becomes
one
minute
longer,
but
clears
up
that
issue.
I
think
it
would
have
a
lot
more
value
if
you
just.
D
So
while
I
agree,
I
would
still
focus
on
the
activity
part
for
now,
because
I
don't
think
I'll
have
time
to
cover
the
entire
transition
from
the
old
way
to
new
one,
but
that
I
would
expect
to
be
an
official
tutorial
sometime
soon,
but
definitely
not
planning
to
cover
it
today,
because,
based
on
my
experience
covering
it
before
it's
easily
one
hour
plus,
because
the
way
you
subscribe
to
activity
or
diagnostic
source,
the
way
you
publish
it's
all
much
more
than
a
single
line
of
code
like
several
lines
of
code.
D
So
for
the
purposes
of
explaining
activity,
I
would
just
stick
to
what
is
the
current
state.
This
was
just
mentioned
just
to
prove
that
okay,
there
is
a
different
way
of
creating
activity
as
well,
but
once
we
reach-
or
once
we
get
closer
to
the
g88,
I
expect
there
will
be
a
document
in
the
dot
net
runtime
repo,
which
shows
like
compares
the
old
way
with
a
new
way,
and
that
would
be
a
good
place
to
explain
how
it
is
different,
really
from
diagnostic
source.
D
Okay,
so
I
just
showed
like
two
ways
to
create
activities
and
this
being
the
recommended
new
way,
and
now
I
can
show
how
do
you
listen
to
or
how
do
you
subscribe
to
these
activities
again?
These
things
did
not
exist
previously,
so
you
really
need
to
use
diagnostic
source
version
preview,
six
or
higher
too,
or
anything
in
fibo
to
leverage
any
of
the
code
which
I'm
going
to
show
you
so
again.
This
is
not
open
elementary.
This
is
pure.net.
D
So
the
way
you
subscribe
to
activities
is
by
creating
activity
listener.
So
you
have
an
activity
listener
and
there
are
one
two,
three
four
hooks
which
you
can
use
to
subscribe,
so
I'll
go
over
them
one
by
one.
So
the
first
one
is
there
is
a
should
listen
to
callback
which
gives
you
the
activity
sources
itself
and
you
return
a
boolean.
So
it's
a.
D
How
do
I
show
yeah?
So
it's
a
function
which
takes
the
activity
source
and
returns
boring.
So
here
I'm
blindly
returning
true,
which
means
I'm
interested
in
all
the
activity
sources,
no
matter
who
or
what
the
names
are,
but
the
hook
here
is.
It
will
allow
you
to
fine
tune
what
you
want
to
subscribe
to,
so
it
gives
you
the
actual
activity
source
itself
in
open
telemetry.
D
We
subscribe
based
on
the
name
and
version,
but,
like
I
said
this
is
pure.net
topic,
so
users
are
free
to
do
whatever
they
want
in
inside
here
now.
How
often
this
is
called.
This
is
only
called
once
when
the
activity
source
is
being
created.
So
whenever
you
create
an
activity
source,
this
callback
is
invoked.
D
G
D
Yeah,
it
will
be
core
one,
so
it's
very
similar
to
what
diagnostics
force
used
to
do
when
you
called
subs
like
get
all
subscriptions.
D
You'd
get
callbacks
from
all
the
diagnostic
sources
which
existed
even
before
you
write
this
code,
so
yeah,
it's
just
one
time
and
I'll
run
the
code,
and
you
can
verify
that
it
is
being
the
case
but
yeah.
This
is
just
once,
and
this
is
the
most
important
thing
which
is
naming
is
little
bit
weird
get
requested
data
using
context,
so
this
basically
is
a
callback
which
is
called
just
before
the
activity
itself
is
being
created.
D
So
if
you
come
back
to
the
code,
this
line
would
trigger
the
should
listen
to
callback
and
when
you
are
about
to
do
the
start
activity.
This
is
where
the
get
requested
data
using
context
is
called
now.
Based
on
the
outcome
of
this
callback.
Dotnet
decides
whether
to
create
the
activity
itself
or
not
so
the.
D
How
do
I
explain
this
yeah,
so
this
takes
the
activity,
creation
options
and
it
returns
something
of
the
type
activity
data
request.
Let's
go
over
it
one
by
one,
so
activity
creation
options
contains
these
things.
So,
basically,
these
are
the
things
which
you
could
have
used
in
the
start
activity
api.
So
when
you
start
that
when
you
start
the
activity
these
whatever
parameters,
you
show
I'm
only
showing
the
name
here,
but
there
are
overloads
which,
which
can
pass
more
things.
D
You'll
get
a
data
structure
representing
all
the
creation
options,
the
name
kind,
parent
in
the
form
of
activity,
context,
initial
set
of
tags
and
activity
links
along
with
activity,
source
itself,
so
name
of
the
activity
source
of
the
activity,
the
actual
activity
source
itself.
G
D
Something
else
for
c
for
activity
context.
What
else
can
I
specify
that
anything
or
for
activity
contacts
yeah?
So
there
are
like
one
api
which
I
conveniently
omitted.
So
there
is
an
equivalent
one
called
get
requested
data
using
parent
id,
but
let
me
just
focus
on
the
context
part.
So,
basically,
there
is
an
ap.
There
is
a
overload
for
start
activity
which
let
you
pass
the
parent
context
in
the
form
of
activity
context.
D
So
here,
like
in
the
callback
you
get
options
which
contains
the
activity
contacts
which
you
passed
as
the
parent,
so
it
could
be
like
you
explicitly
passing
it
or
it
could
be
like
implicit,
because
what
I'm
trying
to
understand
is
why
is
this
a
generic
type
yeah?
The
answer
is,
it
can
be
parent
can
be
specified
either
as
an
activity
context,
or
it
can
be
passed
as
a
string
in
the
old,
hierarchical
id
format.
D
For
that
question
for
now,
because
it's
a
longer
topic,
which
I
want
to
avoid
for
making
it
really
simple.
So
for
the
purpose
of
this
tutorial,
I'm
only
focusing
on
the
part
where
you
would
only
use
parent,
you
would
only
pass
parent
activity
as
a
activity
contact,
so
you'll
use.
D
D
If
I
told
you
you
are
passing
you,
you
are
forced
to
pass
it
as
an
activity
contact
or
you
don't
pass
it
and
dotnet
will
take.
If
something
was
active
at
the
time
it
will
be
passed
as
a
parent
context.
Now
let
me
explain
a
little
bit
more
on
what
is
the
return
type
here.
It
is
of
type
activity
data
request,
so
it's
an
enum
which
has
four
options
in
the
increasing
order
of
performance.
So
if
you
return,
none
it's
as
good
as
activity
is
not
created.
D
So
if
you
do
return
none
from
here,
you
basically
tell
that.
Okay,
I'm
not
interested
in
the
activity.
It's
almost
same
effect
as
as,
if
there
was
no
listener
at
all.
In
both
cases,
if
there
is
no
one
listening
or
if
you
are
listening,
but
you
returned
activity,
data
request
dot
now
in
both
these
cases,
net
will
not
create
the
activity
itself.
So
what
that
really
means
is
when
this
line
is
returned,
you'd
have
null
here,
and
there
are
three
more
properties
possible
for
activity
data
request.
D
D
Is
old
data
there
is
a
field
called
at
ease
or
data
requested.
So
when
you
do
propagation
data,
the
activity
is
created
but
ease.
All
data
requested
is
set
to
false
now.
The
use
case
is
this:
is
a
this
is
coming
from
open,
elementary
spec
as
well.
D
So
when
you
create
spans,
you
have
something
called
span:
dot,
ease,
recording
and
the
library
others
will
use
that
to
figure
out
whether
someone
is
interested
in
getting
the
whole
data
or
not
and
based
on
that
they
choose
to
enrich
the
span
or
activity
further
or
they
choose
to
just
ignore
it.
So
the
activity
creation
option,
sorry,
the
activity
request,
dot
propagation
data
will
create
the
activity
but
set
the
field
to
false.
The
third
is
in
the
increasing
order
it
creates.
D
It
still
creates
activity,
it
sets
the
is
all
data
requested
to
be
true
and
the
last
one
is
all
of
the
above,
and
it
also
sets
the
activity
dot
trace
flag.
So
activity
has
something
called
face:
flags
activity
trace
flags.
This
is
coming
from
the
w3c
specification,
so
the
last
option
here
it
creates
activity
it
sets-
is
all
data
equal
to
true
and
also
sets
the
w3c
flags
to
be
true,
as
also
in
the
increasing
order
of
like
performance.
D
G
Are
the
four
what
what
is
the
use
case
for
these
trace
flags?
What
what's
the
difference
between.
D
D
It's
not
open
elementary
or
dot
net
activity.
It
is
a
pure
w3c
controller.
G
D
That
flag,
what
is
it
because,
when
you
propagate
it
to
the
next,
the
samplers,
our
sampling
decisions,
are
usually
based
on
the
most
of
the
samples
are
written
in
such
a
way
just
respect
the
price
flags.
Don't
do
anything
else,
just
respect
that
place
flag.
D
Okay,
so
this
callback
is
used
to
control
the
activity
creation
and
then
there
are
two
more
callbacks,
which
is
somewhat
is
probably
the
only
thing
which
is
fairly
easy
to
understand.
Now
this
is
a
callback
which
gets
called
only
if
the
activity
is
created
and
you
get
the
activity
itself
stopped
when
the
activity
is
stopped
and
you
get
the
activity
being
stopped
and
once
you
create.
So
this
shows
how
to
create
and
set
up
the
listener.
D
Then
final
step
is
to
register
the
listener
to
the
activity
source
and
this
is
a
static
method,
so
you
just
register
your
listener
and
now,
if
we,
if
I
run
this
code,
we
can
see
like
what
would
happen
like,
but
before
I
actually
run
it
I'll,
just
revise
what
we
already
said.
So
we
are
going
to
create
an
activity
source.
So
we
know
for
sure
this
callback
is
going
to
be
called
at
least
once
because
it's
meant
to
be
called
only
once
per
activity
source
and
we
are
creating
a
activity
using
start
activity.
D
So
I
expect
this
to
be
called
at
least
once
because
this
is
what
can
possibly
interfere
and
prevent
activity
from
being
created,
and
it
also
cause
the
actual
start
to
be
called
if
the
activity
is
happening
or
if
the,
if
this
returns
something
other
than
none
and
then
finally,
I'm
stopping.
So
I
expect
all
these
callbacks
to
be
called
at
least
once
and
now
here,
I'm
also
doing
a
legacy
activity.
D
This
is
where
things
get
a
little
bit
more
complicated,
so
here
I'm
not
creating
any
activity
source,
but
there
is
a
a
built-in
activity
source
with
the
name
as
empty,
which
is
considered
to
be
the
activities
force
for
all
the
legacy
activities.
So
any
activity
which
I
create
using
this
mechanism
will
be
automatically
associated
with
an
activity
source
with
the
name
empty.
D
So,
even
though
we
like
in
this
code,
I'm
not
creating
it,
I
still
see
a
callback
like
this,
which
says
activity
source
is
being
created
and
the
name
would
be
null
oh
empty,
and
here
I'm
starting
an
activity
and
stopping
so
here
also.
I
would
expect
to
get
started
and
stop
callback,
but
I
will
not
be
getting
the
get
requested
data
callback.
When
I
deal
with
the
legacy
activity,
it's
only
called
when
I
deal
with
activity
in
the
new
way.
D
Let's
just
run
it
once
and
see
whether
I
made
no
mistakes,
let
me
just
run
it
so,
as
I
was
explaining
like
when
we
created
the
activity
source
ourselves,
we
got
one
callback.
All
I'm
doing
in
the
callback
is
just
printing
the
name
of
the
activity
source,
and
this
is
something
which
we
did
not
create,
but
the
runtime
itself
created
one
activity
source
to
associate
every
legacy
activities
with
and
then
for
the
activity
which
I
created
using
the
new
api.
D
I
also
got
the
callback
for
get
requested
data
and
I'm
just
printing
the
activity
name
there,
nothing
more
and
since
I'm
returning
all
data,
this
means
activity
does
get
end
up
being
created.
So
that
means
I'll
get
the
start
and
stop
callback
for
the
activity
which
I
created
here,
as
I'm
just
printing
it
and
for
the
legacy
activity,
I'm
getting
the
start
and
stop
callback.
D
D
Guess
that's
pretty
much
what
I
wanted
to
show,
but
if,
if
we
don't
have
other
topics,
we
can
take
questions
otherwise
I'll
move
to
like
next
topic,
which
is
about
auto
instrumentation.
I
I
have
a
couple
of
questions
so
first
one
the
activity
is
now
disposable
right.
J
I
And
then
also
the
when
I
create
activity
source,
it's
also
disposable
right.
So.
A
I
And
the
the
lifetime
of
activity
source
is
supposed
to
be
the
lifetime
of
application.
Is
it
correct?
Yes,
so
normally
you
would
like
register
it
in
your
dependency
injection
and
you
let
it
and
you
let
the
balance
injection
frame.
D
I
D
So,
in
an
actual
open,
elementary
use
case,
we
made
it
like
more
clear
because
in
we
have
examples
where
I
think
we
yeah.
This
is
a
good
example,
so
I'm
switching
a
little
bit
to
open
elementary,
but
underneath
things
are
same
so
we
register
it
into
da
and
when
the
when
the
container
is
disposed,
it
disposes
open
elementary,
which
internally
disposes
the.
In
fact,
we
only
dispose
the
listener,
so
we
won't
get
called
back,
but
there
is
nothing
else
to
be
disposed
in
the
activity
source
itself.
I
And
this
this
ad
activity
listener
it
returns
white.
It
is
not
disposable
right.
E
I
D
D
G
Just
to
clarify
activity
dispose
and
activity.
Still,
it's
not
the
same
right.
So
when
the
activity
stopped,
it's
it
just
stopped,
but
we
can
still.
It
is
still
being
brought
like
it's
stopped
before
it
enters
the
sdk
pipeline
when
activities
stopped
so
so,
stop
means
the
end
of
the
logical,
logical
action
represented
by
this
activity.
Yeah
so
say
that
activity
don't
stop,
but
after
this
you
can
still
add
the
tag
to
it
and
they
can
still
like.
D
Yep
yeah,
that's
right!
So,
even
after
even
after
you
dispose
an
activity,
you
can
technically
do
change
its
things
like
you
can
add
text
to
it.
But
this
is
a
big
open
question,
because
in
open
telemetry
span
there
are
restrictions
on
what
can
be
done.
However,
the
dotnet
runtime
does
not
put
any
restrictions
on
activity.
So
technically,
if
I
stop
it
here,
I
can
still
do
things
like.
D
D
Into
stop
but
stop
does
not
call
introduce
polls
yeah,
that's
my
understanding,
but
you
cannot
trust
me
hundred
percent.
I
need
to
okay
later.
D
Still
change
that,
for
my
understanding
like
like,
why
is
it
disposable?
Is
there
some
resources
or
why
is
it
disposable.
I
The
disposable
is
because
well
when
we
initially
did
an
activity
there,
it
was
there
was
a
start
and
stop.
But
it's
just
nicer.
If
you
write
using
activity
and
then
you
don't
stop
it
and
or
you
you
have
like
the
using
clause
around
it.
D
G
So
the
idea
is
that
say,
an
instrumental
library
and
the
library
goes
using
activity
using
start
activity
when
it
begins
the
dependency
processing,
thingy
and
then
at
the
end
of
it.
It
just
closes
the
using
statement
and
it
is
there
full
understanding
of
the
library
that
subsequently,
the
activity
is
already
disposed
by.
It
is
still
being
used
by
the
serialization
pipeline
to
you
know
to
turn
it
into
to
export
it
basically
right.
So
that's
that's.
D
Done
yeah,
okay,
fair
enough
yeah,
and
this
is
one
thing
which,
as
you
mentioned
earlier
like
we
have
to
like
document,
because
in
I
mean
we
may
even
have
to
invent
something
else
as
the
thing
which
we
pass
into
our
exporters
because,
right
now
it's
activity
and
technically
an
explorer
can
still
motivate
and
depending
on
the
order,
others
would
still
see
it
but
open
elementary
specs
says
it
should
be
like
readable,
only
or
not
modifiable
at
the
exporter
level.
But
let
I
don't
want
to
discuss
that
today
because
it's
fairly
big
topic.
D
If
there
are
no
questions,
let
me
get
back
to
a
few
other
things
back.
Is
there
any
question
which
I
should
address
right
away?.
D
D
D
So
there
are
documents.
The
current
document
is
purely
about
diagnostic
source
and
activity.
I
expect
it
to
change
sometime
before
they
go
ge.
D
C
D
It's
going
to
be
here,
this
is
a
current
resetting
place
for
activity
user
guide
and
I
think
it
also
has
the
diagnostic
source
user
guide
like
same
place,
but
this
will
be
superseded
with
the
new
guideline
yeah,
but
it
will
be
like
somewhere
else,
not
really
in
our
repo,
but
what
we,
the
example
which
we
have
in
open
telemetry.
D
Okay,
yeah,
let
me
go
back
to
the
agenda
yeah.
This
was
just
intended
to
be
like
quick,
five
minute
tutorial,
but
yeah,
I'm
glad
that
there
are
questions,
but
if
there
is
interest
we
could
potentially
do
a
even
bigger
like
one
hour
session,
which
really
compares
the
diagnostic
source
way
and
the
new
way
and
possibly
explained
a
good,
quite
a
good
migration
path
from
diagnostic
source
to
activity
source,
because
we
know,
like
several
libraries,
will
be
facing
this
question
and
it
would
be
good
to
document.
D
But
if
there
are
enough
interest
we
can
do
it
otherwise,
yeah
we
let
the
library
of
this
figure
it
out
themselves.
C
Yeah,
I
think
it'd
be
good
if
you,
the
chord
samples,
you've
got
as
well.
I
think
for
anybody
that
are
coming
back
to
these
doc,
this
these
notes
it'd
be
useful
for
them
to
just
look
at
as
well.
Okay,
okay,
yeah!
I
can
do
that
part.
Okay,.
D
Yeah,
okay
got
it
yeah,
so
there
are
few
open
questions
we
have
less
than
nine
minutes.
I
think
I
need
to
skip
the
open
questions
and
move
to
auto
instrumentation,
because
we
want
to
spend
some
time
here.
So
let
me
skip
this
and
discuss
it
next
week
and
let's
switch
to
instrumentation.
D
As
most
of
you
are
aware,
followers
created
a
separate
sig
meeting
starting
next
week
for
auto
instrumentation.
So
today
is
the
last
week
where
we
club
it
together
and
previously
we
didn't
have
much
topic
to
discuss,
but
now
that
things
are
getting
really
active,
we
want
a
separate,
sig
and
separate
for
one
hour,
but
one
thing
which
we
really
want
to
discuss.
D
Is
this
part
where
who
would
be
the
initial
set
of
maintainers
and
the
proverbs
and
how
it
should
be
independent,
like
separate
github
groups
compared
to
the
one
controlling
the
sdk,
because
most
likely
the?
Even
though
there
are
some
overlaps,
I
expect
there
will
be
like
complete
different
set
of
people.
B
Yeah
yeah
I
just
to
to
be
sure
and
share
where
we
are
so
the
reaper
is
created
the
sig
meetings
there
I
think
greg
is
working
with
the
last
cleanups
to
do
the
first
push
of
gold
to
the
repo.
I
think
that's
the
next
step
before
that.
I
think
we
we
wanna,
set
up
the
code
owners
for
the
repo.
B
I
I
think
we
talked
a
week
ago
or
two
weeks
ago
me
and
greg
start
as
maintainers,
and
then
we
we
give
approvals
for
anyone
that
wants
to
get
involved
there.
In
the
beginning
we
in
the
beginning,
it's
a
great
time
to
join,
because
then
we
don't
need
to
follow
the
all
the
typical
restrictions
that
open
telemetry
impose
or
have
on
beyond
these
rules.
So
you
don't
have
to
have.
B
I
don't
know
50
reviews
to
be
approved
or
something
like
that
you
know,
but
that's
typically,
just
in
the
beginning,
hopefully
you'll
be
a
busy
repo,
and
we
eventually
get
to
that
point.
But
we
should
I
invite
anyone
that
wants
to
be
approved
to
join
us
there.
So.
G
From
our
side
exactly
so,
we
hopefully
will
add
some
of
our
team
members
to
approvals
for
sure,
because
at
the
beginning,
at
least
until
we
have
like
a
step
an
established
process
here-
and
you
know,
we
want
to
look
at
all
the
prs
from
everybody
and
then,
of
course,
it
will
kind
of
become
more
independent
and
in
terms
of
process,
so
yeah
I'm
working
on
it.
I
think
there
is
a-
and
I
know
that
there
is
a
back
channel
between
open
telemetry
leadership
and
our
product
management
leadership.
G
There
is
a
bunch
of
process
and
four
more
questions
to
take
off
before
this
all
can
happen,
so
we're
talking
through
this.
I
think
it
goes.
It
goes
slowly
because
there
is
a
conference
that
is
pretty
large
for
better
dog
called
dash
coming
up
in
literally
a
week
or
a
week,
and
a
half
or
something
and
a
bunch
of
people
are
very
busy
with
it,
so
I'm
getting
less
traction
than
usual
from
our
product
forks
to
to
deal
with
it.
So
hopefully
we
can
get
this
done
anytime
in
the
meantime.
G
So
this
this
is
in
terms
of
actual
formalities
and
then
creating
a
form
of
work,
and
but
we
can
always
talk
about
technical
stuff
offline
directly,
because
nothing
prevents
us
from
starting
to
do
one.
Some
of
the
technical
items
that
were
on
our
list,
while
we're
still
doing
the
the
whole
formal
things
and
we
can
contribute
them
once
it
actually
did
get
forked.
But
we
can
start
like
you
know,
looking
at
it.
At
my
end,
I
started
looking
at
activities
instead
of
spence.
E
E
Length
of
digit
race
does
it
allow
anyone
to
push
this
ot
repo.
G
G
So
what
that
means
from
like
formal
purposes,
it
is
still
it's
still
some
sort
of
marketing
product
thing
that
may
or
may
not
be
relevant
from
the
perspective
of
your
leadership.
Like
it's
a
public
thing,
I
am
not
a
legal
expert.
G
I
think
if
you
were
to
just
go
and
fork
it
into
open
telemetry
as
an
engineer,
it
can
only
be
a
good
thing
as
a
product
person,
I
actually
have
no
idea
what
what
it
means.
G
So
officially,
I
cannot
encourage
you
to
do
that
on
an
engineering
level.
There
is,
I
do
not
see
anything
that
stops.
You.
E
Okay,
yeah
we
like,
and
you
are
discussing
with
your
company,
to
remove
all
the
attribution
to
data
dock
right.
So
that's
it.
G
It's
not
so
much
that
it's
not
so
much
that
it's
it's
like
if
you
fork
it
today.
You
fork
data
dog
stuff.
If
you
forget
tomorrow,
you
fork
open,
telemetry,
stuff
and
and
like
we
need
product
leadership
to
say,
that's
fine!
We
have
nothing
in
it
or
no.
We
have
concerns
and
I
don't
think
they
have
concerns,
but
we
need
like
them
to
be
okay
with
this,
because
today
you
can
fork
it
and
there's
that's
absolutely
fine.
You
can
fork
it.
G
You
can
use
it
internally
or
you
can
publish
it
as
whatever
you
like,
but
you
will
have
forked
data
docs
technology
right
in
the
future.
You
will
have
forked
a
community
technology
and
that's
the
difference.
C
Okay,
this
conversation's
been
gone,
going
for
quite
a
while
with
their
dog
and
open
telemetry.
So
I
know
that
legally,
there's
they've
passed
over
the
ownership,
but
it
just
hasn't
been
formally
passed
over
to
open
telemetry.
Yet
exactly
and
the
difference.
G
Now
is
just
that
they
kind
of
did
it
and
walked
away
because
they
didn't
see
much
value
in
pursuing
it
and
then
like
really
between
every
individual
language,
to
figure
out
the
right
thing
in
the
photo.net.
I
see
joint
value
in
contributing,
so
I'm
driving
this
for
the
net,
specifically,
what
the
other
languages
are
doing
is
up
to
them
and
I
see
value
so
I'm
driving
it,
but
it's
a
process.
G
So,
as
far
as
on
an
engineering
level
like,
I
am
happy
to
make
contributions
wherever
and
I'm
happy
for
anybody
to
make
contributions
wherever
so
on
a
technical,
but
it's
the
same
as
for
you
guys,
you
also
say
like
we
could
contribute
directly
to
the
dog,
but
we
prefer
to
contribute
to
open
telemetry,
and
that
makes
sense.
But
it
is
the
same
kind
of
issue
right
as
engineers
we're
not
really
blocked
on
starting
to
tackle
some
of
these
things.
D
Okay,
can
I
get
one
minute
back
just
to
ask
to
introduce
the
new
folks
and
there
was
an
open
question
from
I
think
sandra
so
new
folks?
Can
you
please
make
sure
your
names
are
added
to
that
in
the
list
and
we
can
go
around
and
ask
for
a
quick
intro
if
you
want
so
sandra
like
do
you
want
to
say
hi
and
just
like
you
at
an
open
question,
we'll
get
to
it
in
a
moment.
H
Okay,
hi
I'm
sandra
here
from
aws
x-ray,
we've
been
working
with
the
java
and
auto
instrumenter
java,
open
telemetry
repos
for
the
past
couple
of
months.
This
is
our
first
foray
into
net.
As
we
just
released
our
own
auto
instrumenter.
It
seems
like
a
good
opportunity
for
us
to
start
collaborating
on
x-ray
implementation
in
dot
net
open
telemetry.
H
My
open
question
was
just
what
I
mentioned
earlier.
If
you
guys
are
in
a
good
state
to
have
those
conversations,
we
want
to
see
any
opportunities
that
we
can
to
maybe
contribute
to
the
auto
instrumenter
code
base,
seeing
as
we
launched
our
own
and
any
collaboration
opportunities
there.
D
Yeah
so
make
sure
you
definitely
attend
the
news
things
next
week,
because
this
is
mostly
going
to
be
sticking
strictly
to
the
sdk
parts.
The
auto
instrumentation
would
be
a
separate
sig
meetings
starting
next
week.
So
that's
the
best.
I
mean
if
you
are
interested
in
that
area.
That
could
be
the
best
place,
but
yeah
feel
free
to
join
this
one
as
well.
E
B
J
Hey
everyone,
so
I'm
prashanth
I
work
with
sandra
and
bolu
on
the
aws
x-ray
team
and
yeah,
as
sandra
mentioned,
that
we
have
an
active
contribution
going
on
for
the
java
and
we
are
looking
for
looking
to
contribute
to
the
darknet
as
well
as
python,
open,
telemetry
sdks.
You
would
probably
see
me
on
the
python
sig
meetings
as
well.
Okay,
all
right
welcome!
K
Ahead,
I'm
a
software
engineer
from
aws
and
work
with
sandra
and
they
were
recently
we're
currently
in
charge
of
the
aws
x-ray
donate
agent
project
which
aims
to
remove
the
code
change
when
user,
using
the
extra
sdk
and
yeah.
L
Hi,
I'm
rahan
I'm
from
roblox.
I
became
interested
in
the
project
a
few
years
a
few
weeks
ago
and
I'd
be
open
to
contributing.
D
Yeah
welcome
brihan.
Just
like
make
sure
you
message
in
jitter.
I
will
be
available
there,
like
in
case
you
are
looking
for
some
guideline
on
where
to
get
started.
We
cannot
help.
There
are
many
people
who
are
in
active
indexitor
channel
as
well,
okay
yeah,
so
we
are
out
of
time.
So,
if
polo
and
folks
about
auto
instrumentation,
they
want
to
stick
around
and
discuss
feel
free
to
do
so,
but
yeah,
that's
pretty
much
it
from
my
side.
Thank
you.
D
G
G
I
didn't
yet
have
a
chance
to
look
at
it,
but
I
would
definitely
be
excited
to
learn
more
about
your
high
level
architecture
and
see
where
we
can
join
forces
for
sure.
G
So
next
week
we
have
a
whole
hour
just
for
just
for.
G
Auto
yeah-
and
I
think
I
think
the
the
parts
that
I
would
like
to
cover
next
week
is
so.
First
of
all,
I
report
on
where
we
are
with
the
formal
process,
but
regardless
of
that,
whether
or
not
it's
completed
or
not,
I
think
the
next
steps
for
us
is
to
look
at
what
are
the
specific
items
that
we
want
to
tackle
in
terms
of
changes
and
contributions
once
the
fork
is,
does
exist
so
and
through
branches?
G
I
I
do
realize
that
you
guys
like
actually
pushing
this
into
branches.
We
may
need
to
finish
the
formal
process,
but
I
don't
think
we're
actually
blocked
on
actual
dev
work
for
this
so
yeah.
G
I
think
that
that
would
be
something
good
for
next
time,
and
maybe,
if
sarah
and
your
team,
you
guys,
join
and
if
we
can
spend
a
few
minutes
on,
if
you
just
give
a
sort
of
technical
overview
of
your
stuff
and
give
us
some
indications
about
what
oh
let
mr
beck,
what
would
be
very
interesting
is
what
would
you
like
to
use
a
open,
telemetry
formal,
like
branded
tracer
form,
and
you
know
what
what
are
the
applications
that
you
use,
because
you
have
something
on
your
own.
G
So
where
do
you
see
overlaps?
Where
would
you
like
to
emerge
things?
Where
would
you
see
separate
applications?
You
know
how.
How
does
this
whole
thing
fit
together
from
your
perspective
would
be
something
very
interesting
to
understand,
and
then,
once
you
understand
that
the
next
question
would
be
you
in
place
where
there
is
overlap
like
what
you
would
like
to
contribute,
if
anything,
and
what
what
would
you
like
to
use
and
how.
H
Perfect
that
sounds
great.
These
guys
have
just
been
starting
to
dive
into
open
telemetry
this
week
so
and
then,
of
course,
any
additional
code
that
you
guys
are
intending
on
pushing
it'd
be
great
to
have
access
to
that.
I'm
not
sure
if
you
guys
do
that
through
polarquest,
privately
or
if
they're,
just
all
up
on
the
repo
right
now
or
exactly
with
the
mic.
G
So
so
today,
so
we
will
essentially
take
unless
guys
you
have
other
suggestions,
but
my
plan
was
to
take
the
whenever
this
formal
process
is
completed.
I
would
take
the
current
state
of
the
data
dogs
master
branch
at
the
time.
G
I
can
do
either
that
or
I
can
do
the
last,
the
last
release,
which
happens
every
two
weeks,
so
the
delta
between
the
latest
release
or
the
current
state
won't
be
large.
But
since
we're
going
to
merge
back
and
forth
anyway,
current
makes
sense,
and
it's
all
right
now
on
github,
so
you
can
look
at
it
anytime.
G
We
have
some
work
tracking
and
issue.
Checking
is
internal
not
like,
for
example,
the
the
application
and
said
stuff
where
everything
is
in
github,
so
backlog
issues
and
submitted
issues
which
you
currently
check
internally.
G
Github
is
not
completely
up
to
date
in
terms
of
work
items,
but
code
is
up
to
date
and
that's
what
we
use.
That's
the
only
thing
that
you
use.
B
Yes,
are
you?
Are
you
saying
you?
I
saw
that
you're
on
the
guitar
I'll,
send
the
issues
on
open
telemetry
and
we
have
a
quick
overview,
20
minutes
of
the
data
dog
architecture
and
kind
of
the
procedure
from
the
open
telemetry
side,
because
there
are
steps
to
do
and
we
we
did.
I
I
did
basically
the
the
very
basic
bureaucratic
stuff,
but
the
the
real
work
we
should
be
starting
soon.
B
You
know-
and
I
I
think
that
gives
you
kind
of
a
hold
about
where
we
are
in
the
auto
instrumentation
and
the
directions
we
have
kind
of
very
rough
milestones
set
for
what
we
wanted
to
achieve
with
the
project.
B
All
right,
then,
if
no
one
has
any
other
question
or
thing
related
to
auto
instrumentation,
then
we
see
next
week
on
wednesday.
I
don't
remember
the
exact
time.
I
know
that
specific
time
after
noon,
just
pst
4pm.