►
From YouTube: Beyond Getting Started: Using OpenTelemetry to Its Full Potential - Sergey Kanzhelev & Morgan McLean
Description
Speakers: Morgan McLean, Sergey Kanzhelev
OpenTelemetry is a cloud-native set of APIs and libraries used to generate, collect, and export telemetry from distributed systems. This session goes beyond a basic introduction, and demonstrates how you can customize OpenTelemetry’s components and architecture for the unique needs of your app. Attendees will learn how to set up and configure built-in data collectors, how to write their own instrumentation, how to extend and enrich automatically collected telemetry with app-specific information, and how to send this data to Prometheus and Jaeger for analysis.
A
B
Google,
so
this
is
an
advanced
session,
we're
not
going
to
do
the
usual
spiel
about
the
power
of
observability
and
what
tracing
is
and
all
that
I
think
there's
probably
been
other
sessions
at
this
conference
that
cover
that
we're
diving
into
how
to
actually
use
open
symmetry
and
how
to
use
instrumentation
to
solve
specific
scenarios
in
your
application.
However,
in
case
you're
in
the
wrong
room-
or
you
just
came
in
here-
fun,
open
symmetry
provides
makes
robust
portable
telemetry
a
built-in
feature
of
cloud
native
software.
B
Well,
that
actually
means
is
that
we
give
you
a
way
to
extract
signals
and
metrics
and
relevant
telemetry
information
from
your
application.
So
you
can
then
send
them
to
a
back-end
for
processing.
We
don't
do
the
backend
part
we're
not
Prometheus
we're,
not
Yeager
we're
just
the
components
that
you
add
to
your
application.
To
get
that
Salama
tree
out.
Open
Salama
tree
has
a
few
core
components.
B
These
integrations
are
the
reason
why,
when
you
start
using
open,
telemetry
and
you're
using
an
HTTP
library
or
g
RPC
or
a
storage
client
that
you
don't
have
to
go
and
instrument
those
huge
yourselves,
you
don't
have
to
go
and
write
a
create
your
own
latency
metrics
for
your
various
endpoints,
because
we
offer
integrations
that
do
that
for
you
and
that's
the
real
power
of
the
project.
Next,
we
have
libraries.
B
These
are
actual
implementations
opens
laboratory
allows
you
to
bring
your
own
implementation
if
you
want,
but
we
also
have
a
single
set
of
standard
implementations
that
we
expect.
Most
people
are
probably
going
to
use
these
libraries
take
care
that
take
care
of
things
like
distributed,
trace,
context,
propagation.
They
take
care
of
sampling,
they
take
care
of
all
the
sort
of
nasty
bits
that
you
really
don't
want
to
have
to
implement
yourself
time
and
time
again.
Finally,
we
have
exporters.
B
Exporters
will
send
the
data
that
you
capture
the
data
that
you've
defined
to
your
back-end
of
choice
that
might
be
Prometheus,
it
might
be.
Jaeger
might
be
one
of
various
one
of
many
various
commercial
offerings
and
we
have
collectors
we're
not
going
to
dive
too
much
into
the
collector.
In
this
session
there
was
some
pretty
good
conversations
about
the
collector
at
the
observability
talk
on
Monday.
B
The
collector
is
something
you
can
run
as
a
network
service
or
an
agent
I
can
do
things
from
just
proxying
the
telemetry
that
you're
collecting
and
sending
it
to
different
backends,
or
it
can
capture
system
metrics
and
things
like
that,
but
we're
not
going
to
dive
into
too
much
of
data.
During
this
talk,
it's.
A
A
Morgan
said
open,
Salima
3
provides
a
full
solution,
our
full
solution
for
telemetry
collection,
and,
if
you
add,
Jagger
or
zip,
you
know
parameters,
you
get
complete
insight
into
application
behaviour
through
distributed,
tracing
and
matrix.
If
you
add
some
managed
solution
from
one
of
the
commercial
vendors,
be
it
as
your
monitor,
Google's
tech
driver,
I,
wouldn't
mention
all
other
vendors
working
with
us,
but
exhaust
and
you'll
get
full
stack
full
stack
miner
with
turnkey
thermalized
back-end.
A
This
is
telemetry
flow
from
through
the
components
of
open,
telemetry,
API
gets
signal
from
application
and
then
translates
the
signals
into
hdk
and
sdk
3
the
signals
as
a
telemetry
items.
It
has
a
symmetry
model
as
its
element
lis
been
pushed
through
the
processor
and
exporter
pipeline
through
out
of
application
process
through
collector,
then
collector
I
decide
like
massage
the
data
process
it
and
reach
this
data
and
then
send
it
to
one
of
the
bakit
of
your
choice.
Using
collectors.
A
So
open
sea
limited
is
a
complete
solution.
You
don't
need
any
other
components.
You
may
find
all
of
them
on
this
diagram,
but
provides
in
a
full
solution.
We
still
allow
a
lot
of
room
for
innovation,
so
we
say
we
brought
in
all
those
extensibility
points,
so
you
can
extend
every
single
of
these
components
or
completely
replace
them.
When
we
talk
look
at
a
sensibility
and
with
design
extensibility,
we
try
to
strike
a
balance
between
being
flexible
and
being
powerful
out-of-the-box
we
trying
to.
A
If
you
look
at
extensibility
points,
you
look
at
them
from
right
to
left.
First
extensibility
point
is
ability
to
configure
collector
to
send
data
to
various
backends.
It's
very
easy
extensibility,
it's
very
easy
to
use
and
you
can
configure
that
at
any
moment
of
your
application
lifecycle,
because
it's
configured
out
of
process
in
a
collector
process.
Second
extensibility
point
is
a
ability
to
configure
collector
to
process.
Your
data
is
the
way
you
need
to
process
it.
You
can
aggregate
certain
metrics
and
don't
aggregate
others.
You
can
filters
pants.
You
can
enrich
telemetry
visit
additional
attributes.
A
All
those
is
available
through
configuration
throat.
Extensibility
point
is
a
interesting
one.
Sometimes
in
your
environment,
you
cannot
install
additional
collector
additional
process,
a
sidecar,
to
run
and
process
your
telemetry.
In
this
case,
you
need
our
expert
err
from
inside
the
process.
Communicating
directly
to
the
backend
of
your
choice.
A
Sometimes
we
need
to
do
it
because
of
performance
reasons,
and
sometimes
some
attributes
that
you
want
to
associate
user
telemetry
are
simply
not
available
in
the
collector
and
finally
thieves
and
the
most
extreme
extensibility
point
is
the
ability
to
completely
replace
entire
SDK
and
whole
stack
offer
telemetry
processing
to
something
completely
new
like
you
can
rewrite
the
entire
stack,
and
the
reason
for
this
extensibility
point
is
that
our
inspiration
is
to
make
telemetry
a
built-in
feature
of
every
application.
So
you
don't
want
to
lock
you
into
solution
of
Scylla,
meter,
processing
or
the
data
model.
A
A
We
typically
operate
with
a
span
that
represent
the
duration
of
time,
but
some
system
only
a
present
start
event
of
a
span
and
add
two
vendors
fun
it.
What
we
want
to
enable
this
type
of
extensibility
for
those
vendors,
while
we
enable
all
those
extensibility
points,
we
truly
believe
that
most
of
you
will
never
need
all
of
them.
You
probably
will
be
fine
with
like
a
few
api's,
and
we
want
to
make
sure
that
we
have
all
this
API
is
easy
to
use
easy
to
configure
it
easy
to
understand.
A
A
Finally,
you
can,
you
may
want
to
fine-tune
telemetry
that
you
collect,
and
this
is
a
processing,
API,
processing,
enrichment,
API
and
some
API
is
like
expert
or
API
will
mostly
be
used
by
Salima
tree
vendors,
and
we
not
going
to
cover
it
in
this.
Talk
with
this,
I
want
to
switch
to
Morgan
to
make
a
getting
started.
Demo
like
how
to
get
started
with
open
telemetry.
B
Alright,
so
we're
gonna
show
a
very
simple
example
of
how
to
get
started
and
then
we're
gonna
go
into
the
beyond
getting
started.
Part
that
you
were
promised
in
the
title
of
this
session
so
for
getting
started.
We
have
a
common
scenario.
We
have
a
client
that
calls
the
server
we're
just
gonna.
Do
this
single
to
hop
scenario?
There
are
obviously
bigger
examples.
B
If
you
have
10
micro
services,
you'll
have
a
client
that
calls
a
server
which
has
a
client
that
calls
another
server
and
so
on
we're
just
doing
a
simplified
version,
but
we're
gonna
show
context
propagation
for
tracing
and
how
easy
it
is
to
get
started.
So,
like
I,
said,
client
calls.
The
server
server
sends
a
response
to
the
client,
the
those
who
are
less
familiar
distributed
tracing
the
client
is
going
to
create
something
called
a
span
that
tracks
the
amount
of
processing
time
done
on
the
client
and
other
other
metadata.
B
The
server
will
then
generate
its
own
span,
which
should
be,
of
course
shorter
than
the
clients
fan
and
it'll
be
a
child
of
it,
and
the
context
that
sort
of
trace
ID
would
propagate
between
both
is
how,
on
the
back
end
in
Jaeger,
we
know
to
stitch
those
together.
Let
me
change
inputs
and
go
to
the
demo.
What
I
have
here
is
that
big
enough
for
everyone
I
hear
nothing
so
I
assume
it's
fine.
B
What
we
have
here
is
a
very
basic
nodejs
application,
we've
a
client
and
a
server
we're
looking
at
the
client
code
right
now.
It's
our
hello
world
example.
This
is
on
our
open
salami
tree,
JavaScript
github,
and
it
is
quite
literally
what
you
expect.
You
have
a
client
here.
It
makes
a
request
to
localhost
for
the
hello
world
endpoint
and
just
waits
for
response
and
on
the
server
side
it
spins
for
about
two
seconds
and
then
responds
to
it
very,
very
simple.
B
The
only
thing
that
we've
done
here,
the
only
code
that
we
have
that
is
specific
to
open
salami
tree-
is
that
we've
imported
the
core,
open,
telemetry,
Java,
Script
library,
and
then
we've
just
told
it
to
set
up
the
tracer
and
exporters
for
the
HTTP
client
service.
At
no
point,
do
we
generate
a
custom
span?
At
no
point,
do
we
have
to
handle
sampling
or
context
propagation
or
anything
else?
This
is
all
done
automatically
through
the
integrations
that
are
built
into
opens
lemon
tree.
This
is
the
real
power
of
the
project.
B
You
don't
need
to
do
any
of
this
boilerplate
code
yourself
and
so
we'll
get
this
running.
The
server
code
is
remarkably
similar,
so
we
got
the
server
running,
got
the
client
running
and
we'll
go
over
to
Jager,
which
was
already
running
in
the
background.
Actually
has
some
trace
it's
already
captured
and
if
we
hop
into
one
of
those
traces,
we'd
already
captured
refresh
it.
If
we
want
to
see
a
new
one
there,
we.
B
Like
this
is,
this
is
live.
Running
I've
got
two
captured
in
the
back
in
the
background,
just
in
case
things
go
wrong,
but
this
this
is
the
trace
that
we
literally
just
sent
in,
and
we
can
see
the
two
spans
that
we
expect.
We've
got
a
root
span
here
for
the
clients,
that's
just
tracking
the
the
operations
happening
of
the
clients.
It
then
sent
out
a
request
and
we
can
see
the
operations
happening
on
the
server
as
we
can
see.
The
difference
between
latency
on
these
is
incredibly
small
they're,
both
running
a
local
host.
B
Obviously
it's
gonna
be
pretty
quick,
but
this
simple
example
is
powerful,
because
if
we
can
see
how
little
code
to
have
few
code,
changes
are
required
to
take
place,
ID
to
import
a
library
and
tell
it
I'm
using
HTTP
go
use.
Http
vary
with
just
a
couple
seconds
of
work.
We
got
this
to
happen
automatically
and
we've
done
it
also
in
a
way
where
it's
linked
to
source
control,
and
we
can
manage
it
ourselves,
we
can
roll
it
forward,
roll
it
back.
B
Okay,
so,
as
promised,
this
session
is
titled
beyond
getting
started,
so
what
we're
gonna
do
for
the
next
next
20
minutes,
roughly
is
walk
through
different
scenarios
that
you,
as
developers,
are
gonna
commonly
run
into
and
show
you
how
you
handle
these
with
hope,
inflamatory
and
talk
about
best
practices.
The
first
of
these
scenarios
is
a
basically
based
on
what
we
just
did.
We've
the
client.
The
client
calls
the
server
but
there's
a
long-running
task
on
the
server
and
the
scenario
here.
B
It's
once
again,
it's
just
there's
a
sleep
statement
for
two
seconds,
but
you
can
imagine
a
workload.
You
know
in
your
everyday
job,
where
you
have
something
you
know,
chand
requests
and
one
of
the
services
that
that
chain
passes
through
has
something
that
takes
some
time,
something
that
is
worth
tracking
independently
and
you
can
create
your
own
span
for
it
so
that
every
time
a
trace
goes
through
that
service,
you
can,
you
can
actually
analyze
how
long
that
long-running
operation
took
generally.
B
And
we're
gonna
look
at
the
server
code,
so,
like
I
said,
the
server
is
similar
to
the
client.
We
imported
open,
Salama
tree
core,
we
put
on
the
same
aged.
We
then
imported
the
HTTP
server
instrumentation
and
because
we
want
to
add
some
custom
instrumentation,
we
have
to
add
a
little
bit
of
code
right,
open,
Salama
tree
can't
magically
determine
what
you
think
is
worth
tracking
and
so
as
a
developer,
you
have
to
tell
it
so.
The
first
thing
we're
gonna
do
is
create
a
reference
to
the
tracer.
This
is
just
something.
B
B
We
get
the
current
span
that
was
already
captured
by
the
automatic
instrumentation
and
then
we're
to
create
another
child
span.
On
top
of
it,
we
also
log
what
we're
doing,
and
we
just
tell
it
to
create
the
child
span.
Now,
of
course,
a
span
has
a
duration
attracts
you
know
the
start
and
end
of
an
event,
so
we
also
need
to
close
the
event
close.
The
span
so
here
once
we've
finished
our
little
timeout
or
two
second
sleep
statement.
B
B
Well,
that's
not
supposed
to
look
like
that.
So
good
thing,
I'd
already
had
a
tab
open.
So
this
is
the
three
spans
that
we
expect
to
get
that
from
that
operation.
So
we've
got
the
two
spans
that
were
automatically
captured
from
our
HTTP
requests
through
our
services
and
we've
got
an
additional
one.
That's
tracking
the
long-running
process
on
this
machine
with
just
a
few
lines
of
code
we've
not
only
gotten
the
automatic
instrumentation
we've
not
only
got
tracing
in
context
propagation.
B
A
So
we
just
learned
how
to
how
easy
it
is
to
enable
open
telemetry
and
how
easy
to
collect
spans
beat
automatically
or
manually
through
code
instrumentation.
So
now
we
will
talk
about
scenarios
and
there
will
be
a
lot
of
back-and-forth,
so
I
probably
will
still
be
standing
there
and
talking
about
scenario
first
and
then
swishing
to
code.
First
thing
I
want
to
cover
is
I
want
to
say
that
not
all
spans
made
equal.
A
Sometimes
you
have
some
health
and
point,
and
the
same
point
is
constantly
bombarded
with
millions
of
requests
and
all
of
them
are
200,
ok
and
they're,
typically
very
fast,
very
small
and
solemnity
produced
by
monitoring.
This
request
is
I,
can
hide
user
problems
and
also
its
cost.
You
money.
So
sometimes
you
want
to
filter
it
out.
You
can
feel
the
telemetry
out
on
multiple
components
of
open
telemetry.
A
If
you
remember
the
diagram,
you
can
do
it
in
collector,
but
in
this
particular
example,
I
will
show
you
how
to
implement
custom
sampler
to
filter
it
out
and
very
early
stage
before
sample
spam
is
all
is
even
created
and
other
things
that
I
want
to
say.
There'll
be
switch
of
environments,
we
start
with
no
GS
and
it's
not
like
I.
Don't
like
not.
Yes,
I
just
have
a
point
to
make
and
I
make
it
in
like
five
minutes.
I
think
so.
Wait
for
it
and
I
session
to.net.
B
A
It's
easy
to
enable
open,
telemetry
for.net.
As
for
any
other
languages,
you
import
a
bunch
of
packages
and
then,
as
is
few
statements
so
in
this
particular
example,
I
want
to
monitor
incoming
requests
and
I
want
to
send
them
to
Zipkin
and
I
can
figure
Zipkin
endpoint,
that's
it.
You
have
telemetry
so
now,
like
I,
want
to
compile
this
application
run
it
really
quick
and
I
will
hit
a
house
endpoint.
A
And
now
I
want
to
prove
to
you
that
telemetry
was
actually
connected,
so
I
go
to
Zipkin.
You
remember
I
reconfigured
Zipkin
and
it
will
show
me
in
a
second
two
spans
one
for
weather
forecast.
Another
for
house
I
can
prove
you
that
it's
house,
so
you
see
so
now.
I
switch
back
to
my
application.
I
want
to
configure
sampling
to
filter
those
out.
Let's
close
it
and
it's
very
easy
to
enable
sampling,
I
will
use
custom
sampler
because
open
selamat
result
doesn't
know
which
endpoints
are
synthetic
as
health
endpoints.
A
My
custom
sampler
will
answer
the
question:
should
I
sample
method?
Name
is
very
descriptive
and
based
on
name
will
span
I
either
her
return
decision
false.
Please
don't
sample
or
I
pass
the
decision
to
another
sampler
that
will
be
make
more
advanced
decisions.
So,
looking
at
this
code,
you,
basically
you
basically
filtering
out
all
the
health
data
and
that
you
don't
care
about
it.
B
A
A
We
filtered
out
certain
spans
now
I
want
to
talk
about
how
to
make
Spence
more
useful,
so
we
increase
ROI
return
on
investments
of
collections
as
pawns
and
pain
for
storing
them
in
a
in
our
cemetery
system.
Very
often,
you
want
to
attribute
your
spans
with
additional
attributes,
so
you
may
want
to
have
some
business
details
associated
is
in
common
request
or
you
might
do
a
tip
with
a
session
that
user
our
brows
face.
It's
very
easy
to
do
in
open,
telemetry
and
many
examples
of
manual.
Instrumentation
are
quite
straightforward.
A
You
have
a
start
span,
you
have
n
span
and
you
have
spent
object
to
add
attributes
for
in
this
sample.
I
want
to
add
attribute
to
automatically
collected
span.
So
you
don't
worry
about
enabling
data
collection,
you
pretty
sure
that
spans
will
be
collected.
You
just
want
to
add
more
information
on
the
span.
A
What
I
want
to
say
here.
Is
there
is
multiple
ways
to
add
attributes
to
the
application?
This
see
this
one
is
extremely
easy
and
extremely
straightforward.
So
you
don't
you
probably
will
figure
it
out
on
your
all
very
quickly,
just
looking
at
our
documentation,
so
I
get
a
tracer
out
of
dependency
injection
here
and
I
access
current
span.
Current
span
was
already
created
by
open
selim
III
automatic
data
collection,
so
I
just
take
it
and
put
an
attribute
for
it.
A
Almost
there
okay
go
back,
and
yes,
this
is
a
news
pan
wasn't
a
minute
ago
and
for
sure
it
has
a
new
attribute.
You
see
you
can
increase
the
value
of
spans
automatically
connected
by
open
cinema
tree
by
simply
pushing
new
attributes
on
it,
but
not
all
attributes
are
made
equal.
Some
attributes
are
very
special.
A
Some
attributes
described
in
your
application
or
the
process
this
the
application
running
into
so
you
can
have.
These
attributes
are
very
special,
not
because
they're
global
for
the
process,
but
because
you
want
to
associate
these
attributes
with
all
the
telemetry
having
a
system
with
all
the
metrics
is
all
the
logs
is
all
the
spans.
So
you
don't
want
to
write
a
line
of
cosine
current
span
attribute
current
metric
attribute.
You
just
want
to
set
it
globally
for
every
selamat
resource
to
consume,
and
it's
very
easy
to
do
in
our
example.
A
So
let's
go
back
into
court.
This
is
wrong
screen.
Let's
go
back
to
code
and
we're
here.
I
go
back
to
a
startup
file,
because
this
is
global
attributes
and
I
said
it
once
for
the
process
I'll
uncommon
couple
of
lines
here.
This
is
like
setattribute
method.
You
see,
I
can.
I
created
new
resource
and
I
associated
a
few
properties
visit.
A
A
So
what
I'm
gonna
do
I
wanna
since
I
edit
this
special
property
here
I
just
gonna
comment
out
this
property
here,
because
every
expert
knows
the
semantics
and
it
knows
that
service
name
needs
to
be
taken
from
resource
API
when
I
ran
this
example
resident
point
will
open
and
what
you
will
see
that
spans
will
still
be
delivered
to
zip
into
the
same
application
name
back
end
up,
even
though
I
commended
it
out,
and
then
they
will
have
additional
attribute
st.
deployment,
tenant,
IG.
A
Go
back
here,
we
go
it's
already
here,
you
see
the
same
application
name
and
there
is
a
deployment.
Tenant.
Id
here
know
that
some
system
will
have
a
special
meaning
for
those
properties,
because
they
global
some
don't
like
Zipkin,
doesn't
have
special
meaning
for
that.
So
we
just
put
it
into
a
set
of
default
name,
value,
pairs
and,
finally,
not
finding
it
anymore.
A
So
resource
attributes
are
very
special
attributes
because
it
spawn
entire
process,
but
there
is
another
dimension
that
the
attributes
can
spawn
into,
and
this
dimension
is
request
dimension,
so
entire
request
may
have
the
same
set
of
attributes
associated
visit
and
flight
ID
for
future
flight
is
a
good
example
of
it.
So
imagine
you
have
a
bit
ation.
Can
you
have
certain
feature
you
want
to
test
the
way
to
test.
The
feature
is
not
only
click
it
through,
but
also
look
at
telemetry
produced
by
flight.
A
So
those
attributes
not
only
spawn
across
all
cinema
3
items
as
a
dimension
for
metric
and
as
a
span
attributes,
but
also
they.
They
typically
involve
some
additional
sampling
projects
that
needs
to
be
taken
flight
IDs
into
account.
You
don't
want
to
lose
a
telemetry
from
a
single
flight
when
flight
is
only
1%
of
like
a
set
up
for
only
1%
of
exposure
so
to
set
cast
to
set
this
khatai
of
attributes,
we
have
a
different
API
called
distributed
context
and
it's
copying
API.
A
So
here
you
have
distributed
context
and
using
statement
in
c-sharp
define
scoping
and
scope.
Is
here
and
you
have
a
flight
ID
and
I
said
the
flight
random
source,
I
I,
take
a
weather
forecast
from
random
source.
Multi
limited
inside
here
will
be
attribute
with
the
distributed.
Tracing
I
won't
go
into
details
because
I
want
to
show
something
even
cooler
so
now
get
ready
for
this,
and
this
has
promised
explanation
why
we
need
a
dotnet
for
flight
idea.
It's
not
only
need
to
be
associated
with
old
Salima
tree
inside
a
single
component.
A
You
may
also
want
to
associate
flight
ID
with
every
component
in
distributed
application,
so
you
want
to
know
how
many
database
cause
failed
for
specific
flight
or,
if
some
user
experience
a
problem
which
flight
ìjesus
user
was
using.
So
you
want
to
propagate
flight
idea
through
the
components
and
you
want
to
do
it
as
a
thematic
as
possible
and
you
want
to
associate
all
telemetry
business
so
once
we
didn't
dotnet
and
ice
P
dot
net
is
first
step
towards
the
global
mission
of
open
telemetry
to
make
Salim
Utley
built-in
in
all
software.
A
A
Okay
for
this
example,
we
will
need
more
application
because
we
want
to
propagate
contacts
through
the
distributed
application,
so
we
need
more
components.
First
component
will
be
windows,
form
application,
long-forgotten
windows
forms.
I
have
two
buttons
red
button,
green
button,
red
button
will
set
and
you,
by
the
way,
notice
that
this
application
doesn't
have
any
open,
telemetry
references,
it's
pure,
it's
like
it's
just
framework,
so
there
is
API
that
is
not
open.
Till
m3p
I
don't
get
confused.
It's
not
like
opens
elementary
terms
or
whatever
it's
dotnet
terms,
but
we
using
those
API
sand.
A
We
are
using
open
slam,
three
applies
and
merging
them
together,
the
sir.
It's
a
long
crowd,
so
we
are
with
this
API.
We
can
say
that
this
operation,
gating
weather
forecast,
is
happening
with
this
flight
idea.
What
I
did
build
threat
and
this
weather
high
forecast
happen
is
fight
as
it
being
green.
So,
let's
start
this
application,
but
it's
not
all
like
I
want
to
make
it
even
more
complicated.
So
let's
get
a
third
application
in
the
mix.
A
This
is
ice.
P.Net
application
out-of-the-box
is
literally
I,
created
the
new
template
and
replace
the
controller.
So
I
added
working
as
well,
you
see
there
is
no
dependency
on
any
external
frameworks
and
no
it's
out
of
the
box.
I
speed,
another
application
and
all
I
spin
net
3.0
applications
go
have
this
feature
out
of
the
box,
so
this
weather
forecast
controller
just
proxy.
All
the
calls
to
my
back-end
applications
that
I
showed
we're
in
a
very
beginning.
A
So
let's
start
this
application,
and
last
thing
I
want
to
do
is
since
context
propagate
context
may
contain
a
lot
of
properties
opens
in
limited,
doesn't
know
which
properties
to
use
for
as
a
dimensions
for
metrics
and
as
a
span
attributes.
So
I
want
to
go
here
in
a
back-end
application
and
I
want
to
tell
my
application
to
take
flight
ID
as
a
attribute
for
my
spans.
So
trust
me
it
taken
like
set
attribute
on
a
span
so
now
I
want
to
start
back
an
application.
A
Uniform
application
send
a
request.
The
first
component,
which
didn't
have
any
open
cinema
tree,
enabled
they
just
propagate
countries.
This
fronted
application
proxied
call
to
the
second
application
which
had
open
ceilometer,
so
it
collects
data
and
it
takes
a
context
out
of
application.
It
what's
more
interesting
is
every
application
on
a
way
also
have
login
and
the
slogan
is
also
built-in
feature
of
asp.net
and
it
also
traces
a
transaction
of
this
operation.
So
lets
me,
let
me
go
to
one
of
the
applications
and
grab
some
box.
A
It
didn't
work,
I
know
why,
because
I
picked,
let
me
double-check:
okay,
okay,
in
the
interest
of
time,
I
promise
you
it
worked,
I
mean
so
all
the
context
flight
ID,
you
said
in
the
first
application
through
dotnet
ap,
is
automatically
converted
translated
into
properties
of
Spencer
Matthews
last
application,
and
we
will
do
more
of
that
for
other
languages
as
well.
So
some
like
I,
showed
you
propagation
for
HTTP,
it's
automatic.
A
Sometimes
you
need
to
have
propagation
for
other
protocols
and
it's
not
automatic,
so
we
need
to
have
api's
to
enable
this
propagation,
especially
it's
important
for
queue
patterns
when
you
take
when
when
there
is
not
a
direct
RPC,
our
correlation,
when
you
need
to
put
messages
in
to
put
context
into
your
messages
and
propagate
the
message
as
a
whole,
so
context
will
be
propagated
as
a
payload
of
as
a
message.
So
for
this
kind
of
scenario
you
need
to
have
custom
logic.
A
A
It's
very
important
for
us
to
feedback,
and
if
you
want
to
get
involved,
there
is
a
session
tomorrow
that
you
can
attend
it's
a
maintainer
struck,
we'll
talk
a
little
bit
about
the
same,
but
mostly
about
how
to
get
engaged
into
the
project,
how
to
participate
and
what
the
benefits
you
get
from
this
project.
Is
that
I
want
to
thank
all
you
for
coming
yeah.
Thank
you.
If
you
have
any
questions.