►
From YouTube: TGI Kubernetes 125: OpenTelemetry
Description
- 00:00:00 - Welcome to TGIK!
- 00:03:39 - Kubernetes News
- 00:13:06 - Telemetry Primer
- 00:23:32 - Deploying Jaeger
- 00:50:44 - Setting Up an Instrumented App
- 01:12:24 - Side-car injection
- 01:28:24 - Viewing Tracing in Jaeger
- 01:38:20 - Code Instrumentation Preview
- 01:45:24 - Wrap-up
GitHub: https://github.com/vmware-tanzu/tgik/tree/master/episodes/124
Come hang out with Josh Rosso as he explores the world of OpenTelemetry. In this episode we'll explore the project and how we can increase traceability within our cloud native applications. Bring your telescope!
A
Hey,
what's
going
on
everybody
happy
friday,
welcome,
welcome
good
to
see
you
all
from
good
old,
boulder
colorado
if
you're
just
joining
us
feel
free
to
say
hey
in
the
chat.
If
you
feel
comfortable,
let
us
know
where
you're
saying
hey
from
this
will
be
a
really
fun
episode.
Today,
I'm
really
really
psyched
about
it.
A
Pouring
myself
a
drink,
real
quick
as
I
pour
some
of
it
on
my
keyboard.
Let's
see
here
there
we
go
okay,
how's
it
going.
Everyone
welcome!
Welcome!
Who
do
we
got
joining
us
so
far?
Maddie!
Welcome
glad
to
see
you
again,
maddie
thanks!
So
much
liam
from
the
uk
welcome
martin
from
the
netherlands,
nice
to
see
you
joy
as
always
great
to
see
you
joy.
We
got
duffy
with
us,
too,
say
hey
to
duffy.
A
If
you're
in
chat,
he'll
be
hanging
out
with
us
abc
welcome,
yeah
nice
to
see
you
steve
great,
to
see
you
again
steve
all
right,
choco!
Oh
the
coc
videos,
yeah!
Absolutely
I'm
glad
you
saw
those
those
are
pretty
cool.
I
I
recently
changed
from
coc
vim
to
a
different
language
server
protocol
client
that
I'm
trying
out.
So
I
might.
A
I
might
make
a
follow-up
video
on
that,
if,
for
those
of
you
who
are
interested
in
in
auto
completion
with
language
servers
with
them
cool
all
right,
welcome
jukka
from
finland
welcome
ameem
chris
we've
got
tim
joining
us
john
shay
bashanchay
from
macedonia.
Awesome
welcome
lee
the
popcast.
Welcome
kristoff,
glad
to
see
you
hey
steve,
how
you
doing
man
long
time,
no
see
waleed
great
to
have
you
back.
A
We've
got
thorston
coming
in
from
germany.
Let
me
make
my
dinging
noises
go
away
here,
all
right
cool.
Let
me
switch
over
to
my
desktop
real
quick
here
and
let's,
let's
have
people
roll
in
and
we'll
talk
a
little
bit
about
what
we're
going
to
be
talking
about
today.
So
pretty
psyched
about
this
episode.
You
know
a
lot
of
the
previous
episodes.
A
I
feel
like
I've
had
some
foundational
knowledge,
or
at
least
experience
doing
the
thing,
at
least
in
like
a
customer
context,
and
this
is
one
where,
like
I've,
set
up
jaeger
a
couple
times
with
customers,
I've
done
some
stuff
back
when
open
tracing
was
the
thing,
but
I'm
pretty
new
to
like
the
tracing
stack
stuff.
So
this
will
be
a
really
good
opportunity
for
us
all
to
kind
of
play
around
see
if
we
can
get
stuff
working
depending
on
how
it
goes.
A
I'm
even
thinking
that
this
could
maybe
become
like
a
one,
a
two
or
three
part
series.
If
we
want
to
build
on
it,
because
I
know
tracing's
becoming
more
and
more
interesting,
so
who
else
do
we
got
joining
us?
I'm
trying
to
see
where
I
left
off
here
tim
welcome
tim
mona
from
germany
welcome
mona
nirmal
nice
to
see
you
vivian
thanks
for
joining
us
vivian
teen
we've
got
alex,
hey
alex
good
to
see
you,
even
though
I
just
talked
to
you
on
a
call
a
couple
minutes
ago
or
hours
ago.
A
I
guess
at
this
point,
serbia,
hey
I'm
doing
great.
How
are
you
thanks
for
asking?
We've
got
alberto
from
colombia,
moz
hello
and
did
it
do
fully
geared
bear?
I
love
it
nice
to
see
you
thanks
for
joining
us.
Adida
antonios
and
rc
anderson
from
montana
love
montana,
as
a
colorado
person
montana's
like
colorado
on
steroids
right,
so
all
right,
everyone
so
again
glad
to
have
you
welcome
to
episode
125..
A
Let's
get
a
little
bit
into
the
news
here
and
talk
about
what's
going
on
in
the
kubernetes
world,
all
right
core
kubernetes,
those
of
you
who
are
working
on
kubernetes
stuff,
especially
if
you're
in
you
know
the
core
repo
some
important
bits
code
thought
for
119
has
been
paused
to
deal
with
a
couple
critical
issues.
We
put
a
link
into
the
hackmd,
so
if
you're
interested
in
seeing
what's
going
on
and
what
kind
of
big
things
are
are
are
being
focused
on
right
now
check
out
that
list.
A
Small
little
thing,
but
again,
those
of
you
who
might
be
working
in
core
could
be
interested
gc,
kates.gcr,
dot
io,
which
used
to
be
gcr
dot,
io
dash
forward,
slash.
Google
containers
is
now
going
to
point
to
the
new
gcr
dot
io
forward,
slash
kate's
artifacts
prod.
So
if
you're
hearing
this
from
me
just
be
sure
that
you
are
pointing
to
that
latter,
one
or
using
the
correct
thing
that
kates.gcr.io
is
pointing
to
right.
So
again,
kates.gcr.io
is
a
vanity
domain
which
is
then
pointing
to
this
other
domain.
A
So
again,
just
something
to
be
aware
of
in
case
it
impacts.
You
really
really
small
stuff
in
the
in
the
core
this
week,
at
least
as
far
as
like
size
of
items
go
all
right.
So
what
do
we
have
going
on
this
week?
What
interesting
things
have
happened?
So
cncf
webinar,
we
have
two
cncf
webinars
to
call
out.
A
One
is
around
the
security
anatomy
of
that
cve.
That
was
talked
about.
I'm
sure
many
of
you
have
heard
about
it
so
check
out
the
two
cve
disclosures,
if
you
haven't
seen
them
eight
five,
five,
eight
five,
five
five
that
is
and
then
eight
five
five
two
a
little
webinar
on
the
cnr
rc
ncf
website
and
another
cncf
webinar,
which
is
kind
of
very
very
timely,
is
an
open
telemetry
one.
Now
I
skimmed
this
one,
I
haven't
watched
it
all
the
way
through,
but
I'm
looking
forward
to
it.
A
Some
folks
went
over
some
of
the
intentions
with
open
telemetry,
where
the
project's
going
and
obviously
getting
our
feet
wet
into
open.
Telemetry
today
is
going
to
be
one
of
the
cruxes,
so
as
a
little
follow
on.
This
will
probably
give
you
some
really
good
background
all
right.
So
that's
it
for
cncf
webinars.
A
All
right
just
check
who
else
we
have
coming
in
here:
hey
everyone
yeah,
as
duffy
pointed
out.
The
key
thing
is
that
gcr
dot
io,
it's
a
vanity
that
first
url
I
mentioned,
is
a
vanity
url.
So
you'll
probably
just
continue
using
that,
but
if,
for
some
reason,
you're
pointed
to
the
one
that
it's
pointed
to
make
sure
you're,
obviously
either
using
the
new
one
or
pointing
to
the
vanity,
which
is
probably
preferable
all
right,
noelle
from
argentina,
welcome
noel
glad
to
have
you
all
right,
cool
all
right.
What
else
do
we
got
going
on?
A
I
heard
some
some
twitter
posts
that
were
a
little
loud
recently
about
what
an
operator
is
and
whether
there
should
be
a
framework
for
it
and
so
on
and
so
forth.
This
is
kind
of
in
that
vein
totally
unrelated,
but
it
kind
of
points
out
that
the
operator
pattern
is
alive
and
well
in
many
contexts
like,
I
think,
one
of
the
things
that
we
think
of
operators,
as
is,
we
want
really
good
ways
to
manage
common
services
so
like
when
I
set
up
kubernetes
clusters
with
customers
they're
like
all
right.
A
How
do
I
give
postgres
to
my
developers?
How
do
I
give
prometheus
to
my
developers
on
and
on
and
on
and
an
operator
is
an
amazing
model
to
codify
that
that
operational
knowledge?
You
have
about
running
that
system
into
a
way
that
can
build
almost
like
a
self-service
sort
of
self-managing
type
framework.
A
I
don't
know,
maybe
a
cleanup
task
or
something
like
that.
There's
a
lot
of
different
angles.
I
think
you
can.
You
could
probably
use
a
shell
operator
to
run
little
little
event
driven
scripts
things
that
trigger
something
that
triggers
something
else
and
so
on
so
pretty
cool
concept.
I'm
actually
going
to
try
to
check
this
out
next
week.
I
think
I've
got
a
little
use
case
for
it,
but
again
just
another
example
of
what
goodness
you
can
do
in
that
operator.
A
Model
cool
now,
longtime
listener
and
I'm
sure
all
of
you
know
steve
steve.
What's
up,
I
know
you're
here
today
there
was
a
podcast
by
weaveworks,
including
steve
and
and
cornelia
as
well
from
weaveworks.
I
think
she's
cto,
now
yep
cto
of
weaveworks
and
lots
and
lots
of
cool
stuff
that
we've
been
seeing
coming
out
of
steve
more
and
more,
around
git
ops,
devops
considerations.
A
What
types
of
metrics
you
should
be
propagating
to
understand
how
to
do
things
in
a
more
automated
way.
So
thanks
so
much
for
all
the
great
content,
steve
keep
it
coming.
We
love
shouting
out
on
tgik
with
all
this
goodness.
So
thanks
again
all
right
and
if
you
have
not
added
popcast
to
your
list
of
kubernetes
podcasts
right
now
is
the
time
like
literally
right
now,
let's
go
ahead
and
subscribe,
because
podcast
has
hit
25
episodes.
A
So
the
popcast
has
been
super
super
interesting
whole
gamut
of
topics
right,
not
just
like
deep,
deep
kubernetes
stuff.
So
it's
super
refreshing
to
see
these
people.
You
know
really
well
in
the
context
of
kubernetes
talk
about
things
outside
of
it,
but
then
also
get
deep
into
how
they
think
about
stuff
in
this
space
so
check
out
the
podcast
I
know
of
it
from
the
youtube
channel,
I'm
sure
you
can
subscribe
on,
like
normal
podcast
apps.
I
know
you're
in
the
the
chat
pop.
A
A
Yes,
we
do
have
hakkam
d-links
for
the
episodes
it
is
hackmdio
or
sorry,
tgik,
dot,
io
forward,
slash
notes.
If
you
haven't
seen
that
yet
cool
cool
all
right
yeah,
I
know
maddie
a
tier
starts
to
form
every
time
I
think
of
core
os
as
well.
It
was
a
really
really
great
company
in
so
many
ways,
so
many
ways,
but
it
lives
on
a
lot
of
the
cool
tech
that
they
built.
Obviously,
at
cd
and
a
lot
of
the
stuff,
that's
an
open
shift
behind
the
scenes
was
built
there.
A
So
it's
it's
really
cool
all
right.
Ahmet
you've
probably
seen
some
of
his
work
with
crew
with
cube,
cube,
cuddle,
plugins
and
all
that
good
stuff.
I
have
not
checked
out
this
series.
I
think
duffy
added
this
today,
so
I'm
really
looking
forward
to
it.
But
what
better
way
when
you
have
a
really
awesome
tool
to
make
some
videos
that
demonstrate
how
to
use
it
like
this
is
like
documentation
on
steroids,
right,
really,
freaking
cool.
A
So
as
somebody
who
has
really
sucked
at
doing
cube,
cuddle
plugins
and
has
been
really
bad
at
things,
like
switching
my
context
around,
as
many
of
you
know,
this
will
be
a
video
series
for
me
to
watch
no
question.
So
if
you
are
interested
check
this
out
and
thanks
for
all
the
awesome
work
met
for
for
all
your
good
stuff
in
the
in
the
crew
realm
and
all
this
enablement
content
too
all
right.
So
last
but
not
least,
a
new
addition
looks
like
atlanta's
virtual
kubernetes.
A
Meetup
is
going
to
happen
and
an
open
invite
for
some
tgik
folks
to
join
us
so
check
it
out
virtual
meetup
for
the
atlanta
july,
meetup,
very
cool,
so
all
zoom,
based
on
yep
zoom,
based
very
cool
yeah.
It's
interesting.
I
hadn't,
really
thought
about
how
meetups
being
virtual
enables
a
larger
group
to
get
out.
Maybe
if
they're
not
as
close
to
just
the
greater
atlanta
area
so
check
it
out,
it
looks
like
the
topics
are
tilt.
A
How
cloud
native
broke,
dev
and
tilt
fixes
it?
That's
a
pretty
apt
title
for
sure
so
check
it
out.
Everyone
add
it
to
your
calendar
if
you're
interested
all
right,
so
that's
it
newswise
all
right.
So,
let's
see
what
else
we
got
going
on
the
container.
Oh
geez,
coreos,
yeah,
totally
agree.
Let's
see
what
else
we
got
sebastian
from
hungary
thanks
for
joining
us.
A
Cool
cool
all
right
looks
good,
so
let's
go
ahead
and
get
right
into
it,
everyone.
What
are
we
going
to
be
talking
about
this
week?
Well,
as
we
know,
it
is
open,
telemetry,
so
there's
tons
of
angles
we
can
take
this,
like,
I
said
I
think
we're
gonna
try
to
set
some
kind
of
basic
stuff
in
place
and
then
see
if
it
makes
sense
to
maybe
build
onto
it,
even
in
future
episodes.
A
So
what
I'm
thinking
we
kind
of
start
off
with
today
is
a
little
bit
around
just
kind
of
the
telemetry
space.
What's
the
problem
we're
trying
to
solve
right,
just
just
kind
of
put
that
out
there
and
once
we
get
that
in
place
and
exclude
my
excuse,
my
typos
are
out
here
telemetry
with
that
in
place,
we'll
actually
set
up
sort
of
like
a
telemetry
stack.
So
I
know
a
lot
of
the
popular
tools
like
zipkin
and
jaeger.
A
A
lot
of
their
examples
still
use,
I
think,
both
of
their
main
examples
use
like
open
tracing.
I
can't
remember
if
it's
open,
tracing
or
open
census,
but
anyways
we'll
try
to
get
some
apps
together,
see
if
we
can
kind
of
get
the
pipeline
together
and
the
flow
together
to
get
some
of
these
bits,
working,
pull
them
in
and
then,
hopefully,
even
add,
add
traces
introspection
to
our
app
as
well.
A
So
that
would
be
a
really
cool
one
too
introspection
to
app
all
right.
So,
let's
start
off
with
a
little
bit
about
open,
telemetry,
so
chat.
I
have.
I
have
a
question
for
you
starting
off
here.
Okay,
so
do
me
a
favor
if
you
have
set
up
any
type
of
like
so
I
have
set
up
a
tracing
stack
in
cubes.
This
can
be
like
zipkin.
It
can
be
jaeger.
It
doesn't
matter
whether
it's
open
census,
open
tracing
or
open
telemetry.
A
If
you've
set
it
up.
Okay
and
then,
if
you
have
not
so
have
not
set
up
a
tracing,
app
or
tracing
stack,
what
I'll
have
you
do
is
go
ahead
and
type
yes
right
if
you
have,
and
no
if
you
haven't,
feel
free
to
shout
at
me
with
capital
letters
if
you'd
like
I'm
just
curious
for
those
who
are
with
us
today,
who
has
set
up
a
tracing
stack,
something
like
zipkin
jaeger,
maybe
open
tracing,
and
then
how
many
of
you
this
is
like
your
first
foray
into
it.
A
Sweet
we've
got
a
really
really
good
mix.
It
looks
like
maddie
essential
for
debugging
kate's.
I
agree.
I've
been
there
without
tracing
tools
and
yeah,
especially
when
you
have
a
big
micro
service,
stack
right.
It's
like
where
did
this
go
wrong
or
where
is
this
taking
a
lot
of
time?
Okay,
cool!
So
that's
a
pretty
it's
a
pretty
healthy
mix
here
this
will
be
good,
so
those
of
you
who've
got
some
experience
using
it
I'll,
be
leaning
on
you.
A
A
lot
feel
free
to
correct
me
if
I
say
something
silly
and
help
me
out
and
we'll
just
go
through
and
see
what
we
can
kind
of
put
together.
So
I
think
kind
of
the
the
first
thing
we
probably
should
call
out
here.
Let
me
just
get
rid
of
this
window.
Okay,
something
we
probably
should
call
out,
is
exactly
what
open
telemetry
is
now.
I
don't
have
the
full
history,
I'm
just
going
off
of
what
I've
heard
at
conferences
and
what
people
seem
to
tell
me.
A
A
A
What?
If
we
go
and
bring
these
projects
together
right
and
we
form
everything
under
the
umbrella
of
open,
telemetry
right-
and
I
know
largely
the
maintainers
of
these
projects
and
the
folks
working
on
it.
We're
tasked
with
you
know
getting
the
community
to
rally
around
this
tool,
or
I
shouldn't
say
tool,
but
we'll
talk
about
what
open
telemetry
is
in
a
second,
but
to
get
rallied
around
open
telemetry
as
a
project
as
an
initiative
and
and
kind
of
bring
all
this
goodness
together
in
a
consistent
manner.
A
So
what
we're
going
to
be
looking
at
today
right
is
this
kind
of
open,
telemetry
bit
and
talking
a
little
bit
about
kind
of
getting
these
stacks
put
together
and
all
the
different
pieces,
so
cleaning
up
my
tabs
here,
a
little
bit
I'll,
just
kind
of
show
you
where
I'll
be
starting.
Today,
let's
go
to
my
terminal,
real
quick,
so
I
have
spun
up
a
terminal.
Thank
you,
cluster
api
for
making
that
absurdly
easy
to
get
a
kubernetes
cluster.
So
right
now
I
have
got
a
little
bit
too
big.
A
There
josh,
I
have
got
a
seven
node
cluster,
and
this
is
what
we're
gonna
be
working
on
today,
one
master
node,
which
is
obviously
just
for
testing
and
then
a
bunch
of
worker
nodes
right
and
for
the
most
part.
As
far
as
the
cluster
goes,
we're
gonna
be
starting
off
totally
fresh
here,
so
I
will
eventually
get
my
text
size
right,
but,
as
you
can
see
pretty
standard
stuff,
I've
got
calico
core
dns,
I'm
running
fcd
as
a
static
pod
cube
proxy
is
obviously
there.
A
A
So
when
we,
when
we
talk
a
little
bit
about
open,
telemetry
right
as
a
project,
it's
something
that
at
least
at
least
from
my
eyes
from
my
perspective
is
definitely
making
a
lot
of
progress.
It
still
seems
like
it's
pretty
early
on,
like
I
did
just
some
initial
scanning
today
when
getting
ready
for
tgik
kind
of
saying,
like
all
right.
So
what
are
the
examples
you
know
you
know
show
me
a
tracing
stack.
How
does
everything
work?
It
seems
like
I
kept
coming
up
with
a
lot
of
open
census
and
open.
A
There's
too
many
opens
now
open
census
and
our
our
other
one,
which
is
the
open,
tracing
api
right
and
and
not
too
many
in
the
open,
telemetry
front.
But
there
are
some.
There
are
some
good
examples.
So
what
I
was
thinking
we
could
start
off
with
is
if
we
set
up
a
stack
together,
I'm
thinking
something
like
jaeger
chad.
If
you
have
different
opinions,
let
me
know,
but
it
seems
it
seems,
like
I
run
into
jaeger,
the
most
you
know.
A
So
if
we
go
to
a
little
bit
about
open
telemetry
here
hoping
or
can
I
read
about
the
spec
cool
all
right,
so
they
have
defined
in
a
lot
of
ways
their
their
api,
which
effectively
gives
you
kind
of
like
sdks
that
you
can
put
into
your
code
right.
So
the
notion
being
with
open,
open,
sorry,
open,
telemetry
and
I
guess
open
tracing
as
well
of
course,
is
when
we
look
at
this
space
right.
You've
got
these
things
like
here:
let's
just
throw
some
boxes
in
here.
A
You've
got
like
service
a
right
and
in
most
of
our
in
most
of
our
architectures,
we've
got
our
micro
lists
right,
like
our
massive
micro
service,
architectures
and
in
a
lot
of
cases,
but
sometimes
even
you
know,
just
bigger.
You
know
single
binary.
Monoliths
too,
it
could
run
into
the
same
problem,
but
you've
got
service
b
right,
you've
got
service
c,
you've
got
you
know.
A
One
of
these
services
could
obviously
be
a
database,
but
let's
say
like
db1,
you
know
kafka
stream,
thingy
right,
you've
got
all
you
got
all
these
different
bits
right
then,
of
course,
on
top
of
all
of
this,
we've
effectively
got
our
clients
as
well
and
as
the
clients
come
in
and
a
request
comes
down
right.
What's
the
path
that
this
thing
takes
right
so
from
a
client's
perspective,
they
probably
know
that
they
hit
this
thing
and
that's
where
their
concerns
stop.
A
But
we
kind
of
created
a
micro
lift
now
right,
like
we
kind
of
have
moved
a
bunch
of
complexity
into
the
networking
layer
in
a
lot
of
these
cases
in
order
to
have
these
more
composable,
smaller
units.
So
like
everything,
it
has
big
trade-offs
and
I
mean
heck
even
with
a
monolith,
you
could
have
the
same
problem.
A
You'd
put
all
these
things
in
one
box,
but
maybe,
like
you,
don't
know
where
in
the
code
which
function
which
package
or
whatever
you're
you're,
having
issues
with
timing
and
and
all
that
good
stuff,
so
we're
going
to
start
off
by
setting
up
yeager,
I'm
curious
what
you
all
said
that
you
used
it
looks
like
steve.
You
said
jager
operator,
that's
what
I'm
thinking
too,
it
seems
like
jager
operator
would
be
a
pretty
good
place
for
us
to
start
here,
cool
all
right.
A
So,
let's
see
if
we
can
get
some
of
these,
these
bits
wired
up
and
then
we'll
we'll
come
back
to
kind
of
the
open,
telemetry
open,
telemetry
space
in
the
docks,
and
I'm
thinking
we'll
probably
try
to
find
a
go
app.
Just
because
that's
what
I'm
a
little
more
familiar
with,
not
that
it
should
be
too
crazy.
But,
as
I'd
mentioned,
when
you're
going
through
each
one
of
these
micro
services
and
instrumenting
them
right.
A
If
this
one's
written
in
ruby
this
one's
written
in,
go
so
on
and
so
forth,
the
notion
is,
we
can
grab
the
sdk
for
the
thing
that
we
need.
We
can
put
our
little
trace
points
and
information
into
the
services
and
then
we
can
see
how
things
move
through
at
a
higher
level
view
from
something
like
jaeger.
A
So
what
do
you
say?
We
tried
deploying
jaeger
how's
that
sound
all
right,
jaeger
kubernetes,
so
we're
gonna
grab
from
the
jager
docks
the
operator
that
looks
like
this
right
here:
yeah
cool,
so
kind
of
like
the
prometheus
operator
right,
I
kind
of
feel
like
jaeger
was
one
of
those
early
ones
that
did
a
really
good
job
with
the
operator
model.
A
Operators
can
have
a
lot
of
variance
in
quality.
I
think,
as
a
lot
of
you
all
know,
but
I
don't
know
overall,
it
seems
to
be
getting
better.
It's
still
still
a
newer
concept,
but
I
think
the
jaeger
one
in
particular
is
pretty
pretty
advanced,
so
we'll
start
off
with
grabbing
the
jaeger
jaeger
operator.
So,
let's
see
if
we
can
find
some
of
the
installation
links
here
there
we
go
cool
all
right,
so
we've
got
cube.
A
Cuddle
creates
perfect,
so
it
looks
like
we're
going
to
deploy
an
operator,
a
roll
binding,
a
roll
and
probably
some
good
old
crds.
So
that
makes
sense.
Let's
go
back
to
our
terminal
and
let's,
let's
get
ready
to
try
this
out
all
right,
so
we'll
make
this
jaeger
folder
go
into
jager
and
like
most
things,
I'm
always
a
little
weirded
out
by
just
just
applying
them
all
without
at
least
taking
a
quick
glance.
A
So
let's
go
ahead
and
let's
just
let's
download
some
of
these
jaeger
things
so
download
sh,
we'll
grab
this
whole
stack
here
all
right
and
we'll
just
take
a
quick
look
in
the
editor
at
what
what
we'll
be
throwing
in
here
with
jager
all
right.
So
looking
good
yeah
we'll
grab
this,
that's
just
the
name,
space
creation
that
should
be
fine,
all
right
and
then
we'll
w
get
this
one
here
all
right!
Good
deal,
that'll
be
the
crd.
You
know
what
forget
it
we'll
just
apply
it
I'll
break.
My
rule
it'll
be
easier.
A
This
way
famous
last
words
right
all
right,
so
let's
go
ahead
and
just
apply
all
these
bits
in
here
and
then
we'll
we'll.
Take
a
look
at
them
in
cluster.
I
think
that'll
be
a
little
bit
easier.
So
if
we
go
back
and
do
a
cube,
cuddle
get
namespace
cool.
So
now
we've
got
an
observability
namespace
from
installing
that
jager
operator
and
then
I'd
expect
inside
of
observability
that
we
deployed
a
jaeger
operator
itself
so
get
pod,
namespace,
observability
and
there
it
is
okay,
so
we're
off
to
a
pretty
good
start.
A
A
So
we've
got
jaeger
installed
and
marcos.
Octant
you
are,
you
are
brilliant.
Why
am
I
not
using
octant?
That's
what
we
should
be,
what
we
should
be
looking
at
right
now,
plugin
manager?
Let's
see,
do
I
have
octet
on
my
system.
I
think
I
do
initializing
plugin
manager
create
dashboard.
Uicreatelistener
cannot
bind
the
assigned
address.
Do
I
have
octet
running?
I
don't
know
if
I
do
octant?
A
No,
I
don't.
I
might
have
an
old
version
of
it
or
something
weird
going
on.
I
don't
know
what
the
deal
is.
Maybe
we'll
pull
up
octant
later
all
right.
So
we've
got
some
of
these
bits
deployed.
Let's
see
if
I
can
grab
the
octant
binary,
real,
quick,
actually
octant
github
see
if
we
can
grab
this
octant
github
download,
okay
cool.
What
do
we
got
here
so
octant
releases?
I
think
as
we
go
through
and
look
at
some
of
these
bits,
it'll
probably
be
easiest
to
look
at
with
octan.
A
So
for
those
of
you
haven't,
checked
out
octant,
you
know
shameless
plug.
It
is
a.
It
is
an
open
source
project
that
vmware
is
mostly
piloting,
but
it's
an
open
source
project
that
runs
locally
uses.
Your
cubeconfig
gives
you
some
visualization
of
your
your
components
and
I
like
using
it
in
tkg
or
tgik
sorry,
my
brain's
so
beat
up
with
acronyms
this
week.
I
got
to
tell
you
when
we
look
at
stuff
in
tgik,
it's
really
nice
to
kind
of
look
into
what's
going
on.
A
A
Let's
go
ahead
and
get
rid
of
octant
right
now,
so
octant
you
can
go
away
whatever
you
were
great
and
then
we
will
wget
octant
bring
it
on
down.
Oh
there's
a
github
ui
change,
yeah,
of
course,
so
I
will
untar
that
grab
octance
all
right.
Let's
try
this
again!
So
is
octant
already:
hey
yeah,
okay,
we're
good
cool!
So
I'm
just
going
to
move
that
into
user
local
bins.
So
we
will
move
octant,
octant
user,
local
bin.
A
I'm
surprised,
github,
moved
releases
out
of
the
top
seems
like
I
mean
when
you
go
to
a
github
repo.
Isn't
that
one
of
the
most
common
places
that
you
go
to
or
is
it
just
me?
Maybe
maybe
I'm
too
much
of
a
consumer
on
github
and
not
enough
of
a
developer?
Okay,
user,
local
bin
at
least
nowadays,
user
local
bin
looks
good
sudo
all
right!
All
right!
Actin!
Don't
fail
me
now!
A
A
A
A
A
Export
what
the
heck
am
I
doing
wrong?
How
is
export
not
found
export?
What
is
happening
today?
Octant
there
we
go
okay,
anyways,
let's
see
if
this
works,
octant
nope
all
right.
Well,
I
guess
octane's
not
gonna
happen
today.
That's
okay,
probably
something
with
some
type
of
collision.
I
guess
anyways,
let's
get
back
to
it!
So
we've
got
our
jaeger
set
up
for
observability
observability
good
deal
and
we've
got
a
jager
operator
set
up.
A
A
Jager
go
there.
We
go
our
little
investigative
there.
We
go
investigative
gopher
here,
okay,
so
so
far
we've
got
the
jaeger
operator
deployed
right.
So
this
will
be
the
jaeger
operator
right
and
it's
just
kind
of
sitting
around
now.
I
think
we
do
know
that
it
probably
introduced
a
crd
like
most
operators.
So,
in
order
to
instantiate
a
version
of
jaeger,
we
should
be
able
to
come
back
here
and
see
cube
cuddle
get
crd.
A
So
if
we
look
into
our
our
jaeger
crd,
we
should
be
able
to
probably
create
instances
of
jager.
Based
on
that,
I
don't
care
cough.
I've
ever
used
the
jaeger
operator
back
when
I
set
up
jaeger
years
ago.
At
this
point
it
may
have
been.
I
think
it
was
years
ago.
It
may
have
been
just
normal.
You
know
deployment
and
all
that
good
stuff.
A
A
Those
are
open
shift
instructions,
okay,
here's
what
we're
looking
for
everyone
right.
So
we've
got
the
jaeger
tracing
api
version
and
the
jaeger,
the
jaeger
crd
kind.
So
what
do
we
got
going
on
here?
It's
probably
simplest
configuring.
The
operator
there's
probably
ways
to
do
like
fancy
back
end
stuff
streaming
strategy.
A
A
So,
let's
see
if
we
can
get
a
quick
jager
instance
set
up.
What
do
you
say?
Let's
go
to
simplest
that
works
right
and
we'll
go
over
to
the
ide
and
inside
of
here
I'm
just
going
to
make
a
new
file
real
quick.
This
will
be
a
new
file.
We're
going
to
call
this
one
jager
now,
let's
call
it.
Let's
see,
this
will
be
an
instance
of
jaeger
right.
So
what
if
we
call
it
now
we'll
call
it
j1
make
it
as
non-descriptive
as
possible.
All
right
here
we
go
so
we've
got
jager.
A
My
ide
is
mad,
but
that's
probably
expected
right,
because
we
have
a
crd
that
it
doesn't
understand.
The
schema
of
the
name
is
simplest.
Let's
call
it
test,
maybe
all
right
cool,
so
I'm
gonna
apply
this
in
the
cluster
and,
let's
see
what
we
end
up
with
so,
and
you
know
what
I'm
gonna
keep
everything
now
that
I
think
about
it.
I'm
going
to
keep
everything
in
that
observability
name
space.
I
think
so
observability
cool.
So
let's
go
ahead
and
put
that
there
all
right.
A
A
What
else
should
we
look
at
everyone?
Probably
the
jaeger
api
or
the
jaeger
api
itself,
jager
cool?
This
is
probably
good
and
then
pod
service
we'll
bring
up
ingress
to
ingress.
Okay.
So
now
now
we're
watching
a
bunch
of
resources
in
this
namespace
seems
pretty
good,
so
we'll
go
in
now
and
try
to
apply
that
j1
yaml
and
see
what
happens.
A
A
So,
okay,
test,
interesting,
okay,
so
quick
observation
on
the
service
front
right
we've
got
test
collector
headless,
which
does
appear
to
be
a
headless
service
right.
We
have
test
collector
and
test
agents,
so
my
guess
is
that
test
did
I
say
test
anywhere
other
than
name
okay,
so
test
must
be
coming
off
of
the
name
right.
Does
that
seem
reasonable,
so
test
collector
test
collector
headless,
as
the
name
implies.
I
would
assume
that
test.
Collector
is
probably
the
service
things
will
be
collected
through,
maybe
we'll
find
out
soon
test
agent.
A
I'm
interested
why
I
needed
to
put
an
agent
here,
we'll
dig
into
that
a
little
bit
too,
but
the
good
news
is:
we
have
a
jaeger
jaeger
testing
test
io.
Oh,
this
is
my
crd
okay.
So
let
me
back
up
I'm
just
starting
to
wrap
my
brain
around
this.
The
name
jaeger
tracing,
it
seems
like
we've
got
that
in
place.
The
status
is
that
it's
running
okay,
it's
interesting.
What
threw
me
off
is
that,
obviously
this
is
just
the
api
object,
and
this
is
the
name
that
I
put
in.
It's
got
the
version.
A
It's
got
my
strategy.
I
think
all
in
one
right
was
because
I
wasn't
using
kafka
or
anything
seems
pretty
good,
and
this
is
new
right.
Oh
yeah,
102
seconds,
okay,
so
pod
test,
which
I'm
guessing
is
my
jaeger
instance.
So
I'm
more
familiar
with
prometheus.
But
when
I
deploy
prometheus,
I
put
in
a
crd
for
prometheus.
The
operator
does
some
magic
and
then
a
prometheus
instance
pops
up
and
I'm
guessing
that's
what
just
happened
with
jaeger.
So
what's
funny,
let's,
let's
check
out
the
ingress
everyone.
So
here's!
What
we'll
do?
A
Let's
do
a
cube
cuddle,
don't
hate
me
we're
going
to
do
edit,
but
we're
not
actually
going
to
edit,
so
some
people
cringe
when
I
use
the
cube
cuddle
edit
command
cube
cuddle
edit
ingress
for
the
namespace
observability,
and
this
is
called
test
query
right
all
right.
This
is
good.
What
do
we
got
going
on
here?
So
managed
fields,
yep,
yep?
A
Okay.
So
if
I'm
reading
the
spec
right
for
the
ingress,
it's
catching
everything
right
is
that
what
you
all
are
reading
to
it
looks
like
this
is
kind
of
a
generic
rule
that,
regardless
of
path
regardless
of
host,
it
should
catch
this
in
route
into
it.
Interesting
interesting,
okay,
now
chat.
Can
you
think
of?
Can
you
think
of
what
I'm
missing
right
now,
based
on
what
we
just
looked
at
so
check
this
out,
get
pods
all
here's
all
my
pods,
roughly,
we
just
looked
at
an
ingress
resource.
A
What
do
you
think
I'm
missing
right
now
that
probably
won't
make
that
ingress
resource
very
successful?
Does
anyone
have
any
ideas
right?
I'm
gonna
check
chat.
While
you
think
that
through
let's
see,
refined
github
is
great.
Always
it's
always
added
to
release
tabs
at
the
top.
Just
issues,
apparently,
rather
than
releases,
could
be
yeah
very
true.
A
A
Yep,
some
of
you
are
getting
it.
It
is
the
ingress
controller.
I
don't
have
one
right
now,
so,
as
many
of
you
know
in
the
kubernetes
space,
and
actually
it's
it's
funny-
I
I
talked
to
a
couple
folks
and
they're-
probably
a
lot
newer
to
kubernetes
than
you
all
are,
but
I
think
one
thing
that
trips
people
up
all
the
time
when
they're
new
is
that
there's
these
apis
in
cube
that,
like
sure
you
can
submit
and
create
them,
but
you
need
something
that
reads
them
and
satisfies
them.
A
So
the
two
that
I
very
commonly
have
people
get
tripped
up
with
is
ingress.
It's
like
well.
What
do
you
mean?
I
need
an
ingress
controller
like
ingress
is
already
part
of
cube
right,
but
the
notion
of
an
ingress
controller
is
it
watches
them,
and
then
programs,
some
load,
balancer
technology
right
like
envoy
or
nginx,
and
then
another
really
common
one.
I
run
into
his
network
policy
right.
Does
anyone
remember
the
glory
days
of
flannel
speaking
of
core
os,
so
flannel
was
a
great
cni.
A
I
mean
it
is
a
great
cni
in
a
lot
of
ways,
although
I
think
it's
kind
of
not
being
maintained
as
much
and
it
didn't
have
a
network
policy
enforcement
so
sure
you
could
still
make
these
network
policy
api
things
or
objects,
but
nothing
would
happen
right
because
there
was
nothing
actually
enforcing
it
right
and
some
of
you
are
going
even
farther
an
ingress
controller,
an
external
lb,
a
load
balancer
service,
potentially
even
a
dns
record
that
points
to
it
right.
So
I
need
to
set
up
some
of
that
stack.
Real,
quick
and
I'll.
A
A
My
favorite
part
about
t.k,
you
saying
tkg,
my
favorite
part
about
tgik
is
getting
to
drink
a
beer
earlier
on
a
friday.
That's
the
that's
the
biggest
bonus
to
it
and
hanging
out
with
all
of
you,
of
course,
that's
pretty
important
too
okay
yeah,
so
you're
totally
right.
We
need
something
we
could
use
port
forward.
We
could
use
anything
since
the
ingress
is
already
there.
I'm
just
gonna
deploy
an
ingress
controller.
Real
quick
it'll
take
two
seconds.
So
let's
use
my
favorite
ingress
controller,
although
I'm
biased
is
contour.
A
Contour
is
an
ingress
controller
that
programs
envoy
based
on
ingress
objects.
So
let's
go
to
project
contours
github,
let's
go
ahead
and
there's
a
quick
start
somewhere,
I'm
sure
getting
started
here.
It
is
quick
start
all
right
now,
this
one,
we
might
need
to
modify
super
quickly.
So,
let's
I
just
w
get
it
w
got
it
in
my
terminal
and
we're
going
to
just
look
inside
of
here.
Real
quick
at
contour,
so
contour
does
a
bunch
of
stuff,
but
what
I'm
most
interested
in
by
the
way
I
started
using
intellij.
A
I
know
vs
code
can
do
this
too,
but
I
usually
just
use
vim
one
of
the
things
I
really
like
that
I
hadn't
thought
about
before
is
this
idea
of
like
taking
structured
documents
like
yml
and
having
like
a
more
structured
way
to
navigate
through
it
on
the
left
side
bar
here,
which
is
probably
looking
pretty
tiny
for
you
all?
But
when
people
send
me
like
a
3000
page
yaml
file,
this
has
been
pretty
cool.
I
can't
believe
I
never
thought
of
doing
this
before
I'm
kind
of
embarrassed.
A
I
one
thing
I'd
love
to
see
from
them.
I
don't
know
if
any
of
you,
you
all
use,
tag
bar
and
vim,
it
would
be
sick
if
there
was
a
yaml
tag.
Bar
extension,
I
think
I
would
just
faint
in
excitement.
Anyways
editors
aside,
so
we've
got
envoy
here.
So
we're
going
to
be
doing
is
deploying
a
daemon
set
of
envoy
that
all
looks
good.
The
image
is
going
to
be
contour.
I
just
want
to
make
sure
the
port
is
using
yes,
okay.
A
So
what
this
means
for
those
of
you
who
might
not
be
as
familiar
the
ingress
controller,
will
sit
on
my
nodes
and
I'm
actually
going
to
let
the
ingress
controller
use
port,
80
and
443
on
the
host,
and
it
does
this
through.
This
thing
called
a
host
port,
which
I
won't
get
too
into
that
there's
implications
on
why
this
is
good
and
bad,
but
suffice
to
say
this
actually
is
exactly
what
I
want.
So
let's
go
ahead
and
deploy
contour,
so
we
can
start
checking
out
jager,
so
cube
cuddle
apply,
contour
all
right.
A
It's
contour,
yemel
good
deal,
so
cube
cuddle
get
pods
for
the
name
space.
What
does
it
go
into?
Is
it
yeah
good?
Guess
all
right?
So,
let's
give
envoy
a
second
to
come
up
and
we'll
see
if
we
can
get
to
we'll
see
if
we
can
get
to
jager
contour
yeah,
carlos
I'm,
I'm
very
I'm
very
biased,
some.
Some
who
know
nginx
like
it
a
lot
better,
absolutely
cool
cool
all
right.
A
So
the
premise
here
would
be,
if
you,
if
you
all
think
about
the
network
path
for
just
a
moment,
what
we're
probably
looking
at
here.
In
fact,
we
kind
of
got
some
more
stuff
going
on.
So
thinking
about
it.
For
a
moment
we
got
the
operator
right.
The
operator
made
will
make
the
the
instances
a
little
bit
smaller
right.
So
the
operator
made
the
instance
right,
which,
what
did
we
call
it
again
was
it
test.
I
think
it
was
test
yeah
correct
me.
A
If
I'm
wrong,
we
made
an
instance
called
test,
so
the
operator's
kind
of
instantiating
this
right
all
right
and
now
the
test
instance
that
we've
got
here.
We've
just
set
up
an
ingress,
so
in
theory,
at
the
edge
of
our
node,
we
should
be
able
to
go
into
ingress,
which
would
be
contour
right,
contour,
all
right
and
then
hopefully,
by
using
contour,
and
that
ingress
resource
will
be
able
to
go
right
down
here
and,
as
many
of
you
know
what
it
kind
of
does
with
ingross.
A
Is
it
points
at
the
service,
but
it
just
kind
of
uses
a
service
as
what
would
you
call
it
a
map?
I
guess
of
endpoints
for
pods,
so
the
the
data
path
here
is
going
to
be
pretty
simple.
I'm
going
to
come
in
as
a
user
hit
envoy
right
and
then
that's
going
to
route
directly
into
our
our
test
instance
here
so
looks
like
we
got
envoy
setup
seems
pretty
good
all
right,
let's
see
if
we
can
get
into
our
cluster.
So
if
we
do
a
cube,
cuddle
get
nodes
o
wide.
A
What
I'm
going
to
do
here
is
I'm
going
to
cheat
so
that
we
don't
waste
all
our
time,
figuring
out
the
routing
and
I'm
going
to
grab
an
external
ip.
That's
not
my
control
plane!
Okay!
So
let
me
let
me
grab
that
sorry.
I
I
put
that
in
there
yeah
there
we
go
now.
You
can
see
it
perfect,
so
I'll
grab
one
of
these
ips
from
the
worker
right
and
then
let's
go
over
to
here
and
in
theory
I
think
the
ingress
set
on
the
root
right.
A
A
A
Oh,
I
do
have
a
service
now,
jager,
query.
Okay,
so
maybe
jaeger
is
tracing
itself.
Does
that
sound
right?
So,
let's
find
traces,
okay,
cool!
This
is
already
kind
of
showing
off
where
we're
headed
with
this.
So
jaeger
query,
we
click
on
one
of
these
okay.
Now
this
is
not.
This
is
not
a
great
representation
of
where
we're
headed
right,
but
it
kind
of
shows
some
of
the
concepts
here
right,
which
is.
There
was
some
type
of
api
call.
A
If
we
open
up
the
operation,
we
can
see
some
information,
some
metadata,
that
kind
of
came
off.
Those
trace
points
is
that
fair,
so
in
the
case
of
jaeger,
we're
probably
not
as
interested
per
se
and
exactly
what
the
trace
points
are.
But
if
we
had
a
more
you
know
larger
service
with
more
things
going
on,
there's
going
to
be
a
bunch
of
calls
to
other
calls
to
other
services
and
we're
going
to
see
all
those
details
come
through
and
what
you'll
typically
see
is
some
type
of
you
know
in
the
tracing
world.
A
Excuse
my
verbiage.
If
I
get
this
wrong,
but
I
tend
to
call
it
like
correlation
id,
which
I'm
guessing
is
probably
gonna
surface,
as
whatever
this
client
uu
idea
is
where,
on
the
instantiation
of
the
request
from
the
client
either
the
client
passes
in
some
unique
euid.
So
you
can
trace
it
on
that
level
or
just
at
the
front
kind
of
gate
of
the
request.
Some
type
of
uuid
is
instantiated
to
represent
that
request,
and
then
the
maybe
maybe
obvious,
maybe
not
point
of
this.
Is
you
want
that
uuid
consistent?
A
A
That's
gonna
change
my
life.
Thank
you
for
telling
me
that
I'm
guessing,
if
I
just
go
into
oh
check,
check
the
tag
bar
repo
okay,
I
will
check
that
out.
That's
pretty
sweet
alberto.
I
use
I
use
arch
linux
just
because
I'm
used
to
it.
The
the
ui
you're
seeing
right
now
is
xfce
or
however,
however,
the
heck
you
say
it,
and
it
is
a
dictionary
yeah.
That
would
make
sense,
given
that
it's
looking
up
all
right
cool,
then
choco,
you
said
or
choco.
You
said.
A
I
believe
it's
trace
id,
they
use
w3,
trace
context.
Spec
right,
you
might
be
right,
I'm
not
sure,
let's
see
if
we
can
figure
that
out
as
we
get
deeper,
I'm
guessing
for
trace
id
yeah,
there's
a
difference.
There's
a
couple
of
things
that
we'll
probably
dive
into
too,
like
conceptually
there's
the
idea
of
the
trace
bucket
right.
There's
the
idea
of
the
the
span
bucket.
I
think
they
call
it
right
and
a
trace
can
have
multiple
spans,
hopefully
anyways.
A
Hopefully,
when
we
get
in
there
we'll
be
able
to
kind
of
dissect
and
see
how
all
these
things
play
out
with
a
bit
of
a
better
app
and
eduardo
from
south
africa.
Thanks
for
joining
us
eduardo
glad
to
have
you
okay,
so
I
guess:
where
do
we
go
from
here?
Well,
jaeger
is
working,
that's
kind
of
cool,
but
I
do
want
to
get
a
fancier
app
going
here.
So
what
do
you
all
say?
Let's
look
into
there's
a
there's,
a
sample
app.
I
saw
it
out
there
on
the
internet.
A
Today,
it's
called
it's
not
hot
wheel.
Hot
gotta
be
careful
with
what
I
type
in
here.
So
it
is
jaeger
example
app
hot
car,
hot
rod.
Hot
rod
is
what
I'm
looking
for.
Yes,
okay,
cool,
so
hot
rod,
all
right
and
hot
rod
looked
like
it
had
a
couple
videos,
a
couple
demos.
Now
I
didn't
see
when
I
looked
at
this
earlier
today.
Correct
me.
If
I'm
wrong,
I
didn't
see
a
kubernetes
example
just
like
with
the
manifest
wired
up.
A
You
can
click
that
I
think
simulate
like
orders
or
something
from
what
I
saw
and
we
should
be
able
to
kind
of
build
some
different
trace
information
through
here
and
see.
What's
going
on.
So
let's
look
at
the
docker
compose
file,
real,
quick,
all
right,
so
docker
compose.
What
do
we
got
going
on
in
compose
all
right,
so
this
yaml
file
for
those
that
aren't
as
familiar
with
compose
composes
a
kind
of
different
orchestrator
thingy?
A
I
don't
know
if
docker's
continuing
compose
or
not
maybe
someone
in
chat
knows,
but
nonetheless
this
is
not
a
cube
manifest.
This
is
a
compose
manifest.
It
looks
like
they
are
running
hot
rod.
Okay,
that's
easy
enough!
So
we
should.
We
should
definitely
steal
this
chunk
right
and
we'll
run
the
hot
rod
app.
It
looks
like
it
gets
interacted
with
on
port
80..
A
A
Cool
cool,
steve,
you
said
you
can
also
run
the
hot
rod
as
a
deployment
with
the
jaeger
agent,
auto
injection,
good
idea.
Okay,
so
there's
probably
something
in
here
about
jaeger,
auto,
injecting
this
out
there
literally
there.
It
is
auto,
injecting
the
side
car,
okay,
sick.
So
if
I
make
a
hot
rod
deployment
we
pump
it
in
and
then
we
attach
the
agent
side
car.
A
Let's
see,
okay,
this
is
probably
what
it
injects
right
and
then
that
can
go
side
by
side
with
hot
rod
to
see
some
of
the
calls
going
through
seem
reasonable,
yep
as
an
annotation.
Exactly
so
there's
that
annotation
right
there
looks
pretty
good
cool
all
right.
So
and
michael
you
asked
if
I'm
gonna
be
talking
about
open
census
today,
so
I
mentioned
it
a
little
bit
earlier
and
I
don't
I
don't-
have
a
ton
of
depth
on
on
open
census.
A
To
be
honest
with
you,
although,
if
you
have
specific
questions,
I'd
be
happy
to
to
talk
more
about
it,
but
if
you
didn't
catch
it,
basically,
what
we're
going
to
try
to
focus
on
is
getting
something
working
and
getting
everything
to
open
telemetry
since
open
census
and
open
tracing
are
kind
of
be.
I
don't
know
if
becoming
is
the
right
way
to
put
it
but
are
merging
under
the
umbrella
of
open
telemetry.
So
that's
kind
of
going
to
be
my
focus
as
we
drive
in.
I
think
hot
rod
uses
open
tracing
apis.
A
A
Let's
see
we
had
contour
down
here
right.
Is
there
a
deployment
for
contour?
Just
to
save
me
some
time
daemon
set
deployment?
I
guess
this
is
okay,
we'll
grab
that
namespace
back
okay
way
more
than
I'll
need,
but
that's
all
right:
okay,
cool!
So
we'll
grab
this
here:
let's
do
a
new
yaml
file
file.
This
will
be
hot
rod:
dot,
yaml,
okay,
let's
get
the
oops
wrong
buffer
josh.
A
Let's
see,
we've
got
the
deployment
here.
Let's
just
start
with
this.
This
will
be
good
enough,
so
we've
got
that
hot
rod
yemel,
let's
paste
it
in
all
right
and
then
let's
grab
the
let's
grab
the
service
or
the
hot
rod
app
here.
So
just
grab
this
to
start
off
with
we'll
do
that
and
we'll
bring
it
in
okay.
So
what
do
we
know
so
far?
Well
inside
of
the
spec,
I
guess
this
is
the
spec
for
the
deployment
right.
I
don't
care
too
much
about
that.
Spec
for
here
is
gonna,
be
template.
A
It's
going
to
be
spec,
it's
going
to
be
containers,
okay,
so
we'll
start
off
by
calling
this
hot
rod
right
and
then
the
image
for
hot
rod
is
going
to
be
this
image
here.
So
we'll
grab
that
and
bring
it
over.
There
is
a
tool
to
transition
compose
files
to
deployment
files.
I
probably
should
be
using
that,
but
that's
okay,
the
command
is
all
I
think,
with
compose
that
actually
translates
to
args
with
cube.
A
I
think
we'll
find
out.
So
args
is
good.
Those
environment
variables
don't
know
if
I
necessarily
need
those.
This
probably
is
a
good
place
to
start.
So,
let's
start
here
real
quick
before
I
worry
too
much
about
the
rest,
so
kind
metadata,
the
name
is
gonna,
be
hot
rod.
Obviously
right
hot
rod,
namespace
is
gonna,
be
observability.
A
A
A
A
A
A
Cool,
I
think,
you're,
all
probably
thinking
man
he's,
he's
really
going
to
regret
not
using
compose,
let's
see
here
so
spec
containers
name
image
the
ports
I'll
put
the
ports
in
in
a
second
selector
match
labels.
Of
course
I
need
to
select
or
match
labels,
so
let's
go
ahead
and
put
that
into
because
obviously,
replica
set
controller
is
going
to
need
to
know
what
to
use
right.
So
the
app
is
going
to
be
hot
rod.
A
A
A
Okay,
in
theory,
this
is
a
hot
rod
deployment
right,
so
we
should
oops,
sorry,
everyone,
my
bad,
I
flipped
I
flipped
the
wrong
screen
all
right,
so
this
should
be
the
deployment
then
yeah,
sorry.
I
know
it's
still
in
the
browser
there.
My
my
video
and
chat
delay
got
me
that
time
all
right.
So
here's
what
I'm
thinking
we've
got
the
match.
A
Labels
we've
got
the
container
for
hot
rod
all
seems
to
look
okay,
let's
go
back
now
that
you
can
actually
see
my
screen
and
let's
see
if
we
can
watch
this
play
out
so
all
right,
so
we
will
exit
out
of
there.
Let's
do
a
hot
rod
deployment
here,
so
cube,
cuddle,
cube,
cuddle,
gets
pods
and
services
for
the
namespace
observability,
which
reminds
me
we're
probably
going
to
have
to
expose
hot
rod.
I
might
just
throw
it
on
a
node
port
for
the
sake
of
simplicity
and
time.
A
Let's
go
ahead
and
watch
this
here,
so
watch
that
good
good,
all
right,
not
too
bad
and
then
cube
cuddle,
apply
hot
rod.
Okay,
hot
rod
give
us
a
pod.
I
see
a
pod
start
for
us.
Awesome,
hey
see
who
needs
compose
when
you're
this
good
at
hand
crafting
yaml
files
right?
Don't
you
all
just
want
to
spend
your
days
hand
crafting
yaml
files,
okay,
anyways?
So
let's
get
the
pod.
Let's
get
the
logs
real,
quick,
just
to
make
sure
things.
A
Look
good
for
the
namespace
observability,
okay,
customer
route
front
end
yeah,
yeah,
choco,
yemel
engineer!
You
know
it
all
right:
cool
cool,
yeah,
flesh,
good
idea.
I
guess
I
should
have
just
put
the
image
in
as
a
as
a
dry
run
right
and
brought
the
yaml
out,
but
you
know
again
handcrafted
yaml
files.
When
I,
when
I
should,
I
ever
end
my
employment
at
vmware
I'll
start
a
company
that
will
be
all
about
handcrafting
yaml.
A
A
Pretty
good,
so
I'm
totally
being
sarcastic
if
it's
not
clear,
anyways,
so
jaeger
metrics
looks
good,
looks
good,
okay,
so
for
simplicity,
let's
not
even
worry
about
putting
this
thing
behind
the
ingress
layer,
let's
just
open
up
a
node
port,
real
quick.
So
basically
all
I
need
is
kubernetes
service
example.
A
I
won't
make
you
watch
me.
Use
autocomplete
here,
do
service!
Look
at
that
beautiful
service!
Okay,
let's
get
back
to
our
editor,
then
so
at
the
top
here
we're
going
to
go
ahead
and
put
in
a
service
for
kubernetes.
The
metadata
is
going
to
be
hot
rod.
The
app
selector
is
going
to
be.
I
have
an
app
label
everywhere.
I
do
good
hot
rod.
Okay,
where
are
we
going
to
forward
to
so
tcp?
A
Let's
just
do
port
8080
to
port
8080,
okay
and
then
what
is
it?
Is
it
type
I
think
it's
type
yeah
type,
node
port
there
we
go!
Look
at
that
yaml
language
server
right
there
looks
great
duffy,
says
punch
cards
over
ocr.
I
would.
I
would
kill
to
see
that
process
done
with
punch
cards
that
would
be
phenomenal,
get
out
the
get
out
the
big
mainframes
again
all
right.
A
A
A
A
A
We
get
this
stuff
working
because
my
thought
process
is,
I
don't
know
much
about
hot
rod,
but
if
it's
not
already
converted
to
open
telemetry
apis,
maybe
I
don't
know
if
this
will
happen
today,
but
maybe
we
could
convert
it
over
to
open
telemetry
that
could
be
kind
of
cool,
so
all
right,
so
hot
rod's
an
app.
I
click
some
buttons.
A
It
says
that
something
is
arriving
in
two
minutes:
desserts,
roasters,
okay,
so
probably
doing
requests
through
some
stack
and
it's
in
its
app
and
probably
has
trace
points
throughout
that
and
is
gonna
gonna,
hopefully
propagate
some
of
these
details
up
to
us.
So
we
can
get
a
good
feel
for
what's
going
on
now,
like
I'd
mentioned,
I
don't
think
jaeger's
gonna
pick
that
up.
A
Let's
test
that
theory,
real,
quick,
so
jaeger
and
yes,
okay,
so
we've
still
just
got
the
jager
query.
So
while
they
are
in
the
same
name
space,
which
is
great,
they
jaeger's
not
automatically
picking
it
up
per
se.
So
I
would
expect
that
I
think,
where
we're
kind
of
at
right
now
then
is
we've
got
our.
A
We
we,
actually
we
don't
even
have.
I
guess
our
test
jaeger
is
pointed
at.
Let's
see
our
test,
jager
is
existent
right.
So
the
question
here
that
I
think
we
got
to
think
about
is:
do
we
want
hot
rod
to
point
to
test
jager
or
do
we
want
to
make
another
jaeger
right
that
points
to
the
hot
rod
right
and
then
remember
if
we
go
back
to
services
here,
remember
these
collector
things,
there's
probably
something
we
need
to
do
to
get
the
app.
A
A
So,
yes,
I'm
missing
that
annotation.
I
am
missing
the
agent
that
makes
sense.
So
let's
solve
that
problem
right
now.
So
what
we'll
do,
just
as
a
little
clean
up
item,
make
sure
we're
kind
of
groking
everything
that's
going
on.
Let's
do
a
quick
watch
again,
so
we're
going
to
watch
an
observability
for
pod
service
jaeger,
and
what
else
do
I
want
to
look
for
ingress?
A
Maybe
okay,
so
this
is
my
stack
right
now
now
the
one
thing
I
don't
like,
as
we
try
to
get
hot
rod
hooked
up,
is
I'm
not
super
crazy
about
the
name
of
j1?
So
let's
try
to
fix
that
right
now.
If
I
rename
oh
the
one
downside
of
using
editors,
I
don't
even
know
how
to
rename
my
file.
Okay,
we're
going
to
keep
it
j1
or
sorry.
A
We
will
go
ahead
and
call
this
j
hot
rod
same
name
space.
I
just
want
the.
I
just
want
the
naming
to
kind
of
line
up
a
little
bit
better.
So
if
we
come
back
to
this,
we're
gonna
do
a
cube.
Cuddle
delete
jaeger
right
and
our
existing
jaeger,
as
we
know,
is
test
all
right.
So
if
we
delete
this
now,
the
operator
should
be
doing
some
cleanup.
There
we
go
so
jaeger's
pulled
out.
We
still
have
the
jaeger
operator.
A
We
still
have
the
hot
rod
app,
which
is
good
and
now,
let's
just
go
in
and
cube
cuddle
apply
the
hot
rod,
jaeger
hot
rod.
Instance.
Okay.
So
this
is
the
jaeger
that
I
am
expecting
us
to
eventually
go
to.
It
still
created
the
ingress
resource,
we'll
double
check,
but
given
the
path
of
the
ingress,
I
bet
it'll
work
the
same
so
yep,
okay,
so
jaeger's
back
up
things
seem
to
be
good.
A
Mutating
web
hook
controller
and
I'm
guessing.
This
is
how
it
does
it.
The
mutating
webhook
controller
goes
through
and
it
can
call
it
can
send
requests
for
yaml
files
out
and
it
can
do
things
like
basically
say
all
right.
I
want
you
to
inject
right
these
settings
into
here.
So
those
of
you
who
have
used
things
like
istio
you've
probably
seen
this
with
how
it
can
inject
envoy
as
a
side
car
right.
So
it
can
actually
go
in
inject
that
and
all
that
good
stuff.
A
Now
I
think
to
your
question
alex
about
one
instance
per
app.
I
think
there's
trade-offs
here.
I'm
guessing
an
instance
per
app
is
common.
It
looks
like
steve
you're
saying
that's
what
you
do,
but
I
do
know
that
there's
a
daemon
set
model
somewhere
yeah
there.
It
is
installing
the
agent
as
a
daemon
set.
It's
a
great
question.
A
I'd
imagine
you'd
end
up
with
like
multi-tenancy
concerns,
like
it's
kind
of,
like
I
don't
know
fluent
bit,
is
a
good
thing
to
compare
it
to
but
kind
of
like
these
models,
where
we're
siphoning
or
pushing
all
the
the
work
through
these
kind
of
centralized
units
on
the
host,
which
can
be
a
nice
model,
but
in
the
case
of
like
moving
metrics
through
and
how
those
discover
the
jaeger
instance.
I
wonder
I
wonder
what
the
downsides
are
there.
There
might
be
some.
A
There
might
be
some
issues.
This
is
convenient
for
several
purposes
like
multi-tenant
scenarios,
but
there
are
scenarios
where
you
might
want
to
install
the
daemon
set
yeah.
So
I
think
the
implication
they're
speaking
to
here
is
probably
the
tenancy
concerns
right
and
it's
funny,
because
if
you
all
think
about
it,
I
feel
like
with
cube
we're
going
further
and
further
down
this
path.
Where,
like
we
want
these
ancillary
platform
services,
but
we
don't
always
want
to
run
them
as
a
agent
or
daemon
set
on
each
host,
and
thus
we
start
bundling.
A
Excuse
me:
we
start
bundling
our
apps
with
more
and
more
services
right,
be
it
envoy
or
something
else,
and
that
has
a
trade-off
in
and
of
itself,
because
once
you
go
into
an
app
deployed
on
kubernetes
and
there's
77
side
cars,
you
know
that's
gonna,
that's
gonna
cause
some
serious
issues
for
you
right,
but
it's
yeah.
It's
an
interesting,
interesting
model.
I'd
be
curious
to
know
what
the
big
damon
set
trade-off
is
or
what
the
damon
set
trade-offs
are
cool.
A
A
A
Okay
complete
the
sample
deployment
available
at
injected
sidecar.
Okay.
So
let's,
let's
see
if
I'm
grocking
this
right,
so
I
would
expect
there
to
be
a
mutating
webhook
controller
that
got
deployed
in
that
initial
deployment.
So
cube
cuddle,
get,
I
shouldn't
say,
mutating
web
hook
controller,
but
configuration
so
when
I
was
talking
to
y'all
about
the
idea
of
a
mutating
controller
that
kind
of
calls
out
and
injects
stuff.
It
should
be
going
through.
One
of
these
configurations:
there's
no
mutating
web
hook
configuration.
So
how
does
it
know
to
inject
the
agent?
A
That's
interesting:
let's
see
if
we
can
make
that
work
I'll,
be
I'll,
be
a
little
surprised,
but
who
knows
so?
If
we
go
over
to
here?
Let's
add
this
annotation
okay
and
then
we'll
go
back
to
hot
rod,
yep
all
right
deployment,
metadata,
annotation,
sidecar,
inject
and
steve.
You
say
you
use
the
name
rather
than
the
value
true.
Is
there
any
reason
to
that
or
true
only
works
if
the
agent
and
operator
are
in
the
same
name?
Oh,
I
see
okay.
A
A
A
A
You
know,
let's,
let's
delete,
let's
delete
it
first.
Sorry,
my
terminal
foo
is
failing
me
here.
We're
gonna,
cube,
cuddle,
delete,
f,
hot
rod.
Okay,
so
hot
rod's
gone,
that's
fine
and
the
service
is
gone
too
great.
Now,
if
we
go
in
and
go
ahead
and
deploy,
hot
rod
now
apply
hot
rod,
cube
cuddle,
apply
hot
rod.
There
we
go
we'll
apply
it
again.
A
What
am
I
missing?
So
it's
injecting
yeah
there's
an
agent
now
wallet
exactly
so.
Why
is
there
an
agent
now
what
the
heck
am
I
overlooking?
So,
if
I
do
a
cube
cuddle,
I
mean
this
is
great.
This
is
what
it
should
do,
but
it's
magic
at
this
point
for
me.
So
if
we
do
cube
cuddle
get
pod
name,
namespace
observability.
A
Let's
look
at
this
real,
quick,
we'll
we'll
cheat
again
edit
observability
okay
check
this
out
check
this
out.
So
we
got
containers
okay,
so
I
didn't
put
that
there,
okay,
so
it
injected
that
ooh.
This
is
interesting.
We'll
come
back
to
this
in
a
second,
so
there
it
is
the
yeager
agent
all
right
chat.
What
am
I
overlooking
here?
There's
no
mutating
web
hook
configuration
yet
it
mutated.
The
pod
am
I
out
of
my
mind
what
what
would
make
that
happen?
A
A
A
A
Jaeger
instance
name
okay
or
the
jaeger
instance
name,
which
is
what
you
were
talking
about
steve.
So
that
makes
sense.
The
following
snippet
shows
a
simple
application:
that's
injected
inject
true,
either
true
or
jaeger
instance
name.
That
makes
sense
when
the
sidecar
is
injected,
it
doesn't
say
anything
about
it,
but
it
it
sure,
as
heck
put
this
thing
in
there
wow.
That's
so
weird.
Is
there
anything
else
that
you
all
can
think
about
from
an
operator
perspective
that
works
this
way.
A
Like
think,
okay,
so
not
that
we
have
to
die
on
this
hill,
I'm
just
I'm
mostly
just
curious.
It's
kind
of
a
thing
I
haven't
seen
yet.
Obviously
you
don't
run
a
istio
operator
that
watches
for
annotations
to
inject
your
pods
with
envoy
instances,
which
I
guess
in
istio's
case
in
any
service
mesh.
Really
you
really
want
that
sidecar
to
be
there
immediately
right,
which
you
can
kind
of
argue
that
with
jaeger,
but
like
the
side,
cars
man,
but
wouldn't
you
know
what?
A
Actually
I
can
prove
that
that
happened
now
that
I
think
about
it,
because
there
was
a
weird
behavior
check
this
out.
It
is
doing
it.
I
can.
I
can
prove
this
and
I
don't
think
I
like
this
model,
but
maybe
someone
can
talk
me
out
of
it
check
this
out
real
quick.
So
let's
go
to
annotations
watch
this
let's
go
here.
A
I
just
remembered
something
I
saw
that
I
thought
was
funky,
but
then
I
got
to
to
multiplex
to
think
about
it
check
this
out,
so
cube
cuddle
get
pods
for
the
name,
space,
observability,
okay,
the
hot
rod
app
is
running
right.
Now
I'm
just
going
to
delete
the
hot
rod
app,
so
it
goes
away
check
this
out
in
theory.
A
If
I'm
understanding
this
correctly,
we
should
see
hot
rod
get
deployed
with
the
annotation
and
then
the
operator
should
redeploy
the
exact
same
deployment,
so
we
should
see
hot
rod's
initial
deployment
start
terminate
in
favor
of
the
second
deployment
that
happens.
Speaking
to
that
like
potential
race
condition,
I
guess
we
should
actually
be
able
to
see
this
and
unless
I'm
going
absolutely
crazy.
So
let's
see,
let's
see
so
hot
rod,
observability.
A
A
A
Well,
I'm
surprised
I'll
put
it
that
way.
Nonetheless,
we
learned
something
cool
today
right,
so
here
we
are
okay,
so
good
news
is,
we
theoretically
might
be
hooked
up
to
jaeger,
let's
see
if
it's
actually
seeing
what
it
needs
to
see
now.
One
thing
I
did
want
to
show
y'all
before
we
got
into
this,
like
crazy
paradox
of
how
the
injection's
working,
let's
do
cube
cuddle,
get
paw
no
service
get
service.
A
Oh
wait
wrong,
namespace,
namespace,
observability,
okay.
So,
just
to
note,
I
have
the
hot
rod
headless
service,
okay,
so
one
thing
I
noticed
when
I
was
in
the
docks:
if
you
look
at
it,
there's
this
reporter
piece
right.
So
I
think
what's
happening
here
is
in
their
example.
This
is
the.
If
you
put
it
in
manually,
I
think
what's
happening.
Is
it's
setting
up
grpc
to
call
out
to
this
jager
collector
headless
service?
Now,
what's
funny
is
here
they
actually
should
be
using
the
downward
api
in
kubernetes.
A
If
which
is
the
notion
of
like
it's
an
api
that,
like
you,
can
do
things
like
namespace
with
a
dollar
sign
so
that
it
basically
will
replace
this
value
with
whatever
namespace
the
the
thing
is
deployed
in,
but
we
won't
bust
their
chops
too
much
for
that.
So
it's
pointing
to
that
service
right.
So
the
key
thing
is.
What
I
would
expect
is
that.
However,
it's
wired
up
that
flag
is
pointed
to
the
j
hot
rod
service
that
you
all
see
right
here.
Right,
j,
hot
rod,
collector
headless.
A
Okay,
let's
see
if
that's
true,
real,
quick
and
then
we'll
see
if
we
can
actually
view
stuff
inside
of
jager,
so
cube
cuddle
get
pods.
This
was
again
I'm
gonna,
I'm
gonna
make
y'all
nauseous
and
edit
here
cube,
cuddle
edit
pod
or
no,
let's
just
do
deploy
for
the
namespace
observability.
It's
gonna
be
hot
rod.
Here
we
go
and
let's
find
that
line
real
quick,
so
there
it
is
check
this
out.
Okay
club,
I
don't
I
don't
know
what
the
tags
thing
is.
A
I'm
guessing
the
tags
is
probably
tags
it
gives
to
jaeger
right.
So
when
you're
looking
it
up,
it
probably
shows
up
in
the
tags.
I'm
guessing
correct
me
if
I'm
wrong
there,
but
here's
what
I
was
looking
for
right.
So
I
think
this
is
what's
largely
linking
us
up.
Hot
rod
collector
headless
again
the
observability
name
space
which
maybe
it
resolved
via
the
downward
api.
We
don't
really
know
at
this
point
and
then
there's
14
250,
which
is
the
port
on
that
service.
I
do
remember
that
so
in
theory,
I
think
we're
looking
good.
A
I
wonder
if
I
needed
to
specify
that
port
in
my
initial
pod
definition,
I'm
thinking
here
like
yeah,
see
how
I've
only
got
container
port
8080
tcp.
This
will
be
a
side.
Car
pod
it'll
be
in
the
same
network
name
space.
Will
that
matter?
Probably
not
right.
I
don't
know,
let's
see
okay.
So
if
we
go
back
to
jaeger
jaeger
ui
here
we
are
okay.
I've
still
only
got
one
service,
so
I've
got
something
well,
let's
make
sure
we
produce
some
data
too.
Now
that
it's
wired
up
so
I'll
hit.
A
Oh,
you
know
what
I
should
have
a
new
node
port
now
shouldn't.
I
does
this
even
work
anymore.
That
would
be
a
problem.
So
if
we
do
a
cube,
cuddle
get
service
for
the
name
space
observability,
my
nude
node
port
is
f,
31364.
Okay.
So
let's
come
back
here,
three
one,
three,
six!
Four!
There
we
go.
Okay,
let's
create
some
data.
A
A
Why,
oh,
no
josh!
What
are
you
doing?
What
are
you
doing?
Get
pods,
sorry
everyone.
So
I
want
the
hot
rod
pod,
because
I
was
going
to
look
at
the
agent
piece.
So
if
we
do
logs
again
namespace
observability
this
here
perfect,
so
I'm
going
to
look
at
the
jaeger
agent
to
see
what
it's
doing.
Okay
check
this
out.
So
what
do
we
got
going
on
here
so
mounting
health
status?
Flags
builder,
client
connection,
grpc,
okay.
So
all
this
is
happening
over
grpc
http
port.
A
Here
we
go
caller
dns
resolver,
so
this
is
where
it
sent
the
update
to
which
should
be
that
headless
service.
I
was
looking
at
I'm
pretty
sure
in
this
ip
is
probably
coming
off
of
the
non-headless
version
of
that
same
service.
So
I
think
okay,
100
116,
25
196
right.
So
if
we
get
service
to
do
no,
no
that
wouldn't
be
right.
What
am
I
saying
it
is
pointed
to
this?
A
A
A
Mutation,
yeah
yeah.
It
seems
weird
to
me
too,
but
again,
like
we
weren't
in
those
design
decisions
when
they
were
thinking
about
it.
So
who
who
knows
adding
an
annotation
to
a
deployment?
It
should
not
redeploy
apps
yeah.
It
is
a
scary
thing.
What's
the
point
to
specify
the
namespace
and
namespace,
if
it's
going
to
be
replaced
with
the
current
namespace,
you
can
omit
it.
In
that
case,
I'm
not
sure
I
follow
the
logic
there.
I
might.
A
Where
was
that
in
the
docs
and
things
like
this
when
you're
writing
stuff
up
in
your
yaml
file,
where
you've
got
this
here,
you
should
be
able
to
use
the
downward
api
to
resolve
it.
That's
what
I
was
saying,
but
I
might
be
misunderstanding.
Your
your
point,
okay,
cool
and
then
bogdan.
You
said
the
last
comment.
The
operator
sdk
is
finally
adding
support
for
admission
web
hooks.
A
Oh
interesting,
okay,
so
that
very
much
be
the.
Why
that's
good
to
know
if
it's
actually
limited
in
the
operator
sdk?
If
that's
what
was
used
to
build
this
thing,
which
totally
could
be
the
case
good
to
know?
Okay,
all
right,
we're
learning
some
good
stuff
here.
So,
let's
see
if
we
can
actually
view
the
jager
ui
now
so
I've
got
more
services.
A
We've
sent
data
through
these
services
seems
pretty
good,
so
we've
got
a
bunch
of
stuff
customer,
we'll
start
with
customer.
That
seems
reasonable.
Let's
find
traces
okay,
so
the
premise
here
should
be
that
we
are
able
to
see
something
come
through
the
entire
stack.
Now
the
hot
rod
app
seems
to
be
all
self-contained.
As
far
as
I
can
tell-
and
there's
probably
all
these
different
trace
points
you
know
pieces
inside
of
here,
if
you
will
that
kind
of
get
broken
up.
A
So
if
I
click
on
one
of
these,
there
we
go
so
this
is
giving
us
a
much
better
representation
of
where
this,
these
kind
of
tracing
libraries
and
adding
them
to
our
apps
make
a
lot
of
sense.
Okay.
So,
by
setting
up
jaeger
by
figuring
out
how
the
wiring
works
right,
we've
got
these
two
connected
now.
So
that's
a
huge
success
and
this
particular
request.
It
looks
like
it
took
about
half
a
second
or
682
milliseconds
right
to
complete
make
this
a
little
bigger,
just
in
case
it's
hard
to
see
682
milliseconds
to
complete.
A
Now,
of
course,
that's
good
data,
but
what
we
really
want
to
know
here
is
where
was
time
spent
and
what
exactly
happened
in
some
of
these
different
areas
right,
so
we
can
see
a
lot
of
really
good
stuff
here,
for
example,
we
can
see
where
we
got
passed
over
from
our
customer
service
here
over
to
the
driver
service
find
nearest
right.
So,
let's
let
me
break
it
down
from
front
end
and
keep
me
honest
here.
Chad,
if
I
say
anything,
silly
how
I
read
this
is
front
end.
A
A
Now
you
know
again
if,
if
it
was
much
larger
or
if
we
saw
these
numbers
happen
under
load
and
so
on,
are
we
no?
We
now
know
where
the
time
is
being
taken.
We
know
what's
going
on.
Perhaps
we
need
to
change
our
connection
pooling
setup
or
you
know
the
5
000
million
things
that
can
make
a
sql
query:
go
faster,
right,
indexing
differently
on
and
on
and
on
now.
A
We
can
also
see
where
the
request
then
got
passed
on,
so
it
went
over
to
the
driver,
driver
service,
find
nearest
okay
and
then
that
breaks
down
into
a
bunch
more
chunks.
Now
this
looks
like
it's
perhaps
multiple
calls
to
redis
right,
so
find
driver
ids
get
driver,
but
you
can
see
how
it's
not
just
one
big
sql
select
right.
It's
all
these
different
calls
and
we
can
click
inside
of
one
of
these
like
find
driver,
ids,
okay,
and
we
can
see
some
details
about
the
information
that
kind
of
went
through
right.
A
A
A
So
all
in
all
looks
pretty
good
and
I
would
imagine,
as
we
send
more
things
in
so
right
now,
let's
refresh
we're
at
six
traces.
If
I
come
in
here
and
start
clicking
more
of
these
with
the
hot
rod
example
right,
we'll
refresh
and
then
hopefully,
oh,
I
might
have
to
do
fine
traces
again
there
we
go
we'll
see
even
more
traces
coming
in
right,
so
we
can
introspect
all
these
pieces
and
get
a
feel
for
for
where
all
they
are
where
they
all
are.
A
But
what
I
want
to
do
before
we
wrap
up
is
just
bring
down
that
hot
rod
app
right
and
just
take
it
just
take
a
quick
look
at
like
what
does
it
actually
look
like
from
a
code
level
when
these,
when
these
different
trace
points
are
being
added
in
and
all
that
good
stuff?
So
we'll
go
to,
let's
see
here
where
was
where's
the
hot
rod
app
at
hot
rod,
github
yeah,
I'll
search
for
it
again,
so
hot
rod,
github,
let's
see
cool.
A
So
what
should
be
happening
here
is
we'll
see
a
bunch
of
like
I
said
I
think
it
said
open
tracing.
We
should
see
it
importing
there.
It
is
the
open
tracing
libraries
using
them
in
various
places.
So
we'll
take
a
quick
look
at
that.
So
let's
go
ahead
and
back
up
here
to
125.,
let's
make
a
dir,
actually
no
we'll
just
clone.
So
let's
get
clone
get
to
clone
there.
We
go
invalid
repository
name
oops.
A
A
A
Okay,
that's
a
very
strange
thing
to
see.
If
I
get
clone,
how
is
a
public
github
repository
not
found
very
strange?
We
can
use
the
ssh
url
and
see
if
that
works.
Okay.
So
all
right
github!
Where
is
my
where's,
my
clone
button
I
used
to
have
with
the
ssh
url
I
have
my
git
config
setup
to
replace
https
with
the
ssh
url
anyways
though,
or
the
git
url.
I
should
say
all
right
github.
I
don't
know
how
to
use
you
anymore.
Unfortunately,
so,
let's
see
here
sage
get
url.
A
A
A
A
A
A
A
A
A
This
is
a
span
and
this
is
a
span,
and
I
think
the
overall
structure
here
is
just
considered
a
trace
end
to
end
yeah.
I
think
that
makes
sense.
So
the
idea
is
that
with
we
can
pass
around
the
context,
and
then
inside
of
here
I
believe
what
it's
doing
is
it's
actually
putting
in
the
details
for
each
one
of
these
things
that
we're
seeing.
So
I
wonder
I
want
to
see
if
I
can
actually
pull
together
something
in
the
code.
That
represents
something
that's
actually
happening
in
the
span
here.
A
So
let's
go
back
to
this.
Let's
find
traces
one
more
time,
so
I'm
inside
of
customer
right,
customer
yep
and
inside
a
customer,
I'm
in
the
database
go
file
right
now.
Okay,
so
that
means
inside
of
here
make
sure
we
have
customer
we'll
find
traces,
and
then
these
are
all
get
dispatch
for
customer
I'll,
open
up
customer.
A
Okay,
let's
see
if
we
can
figure
out
where
one
of
these
are
at
so
my
sequel,
sequel
select
is
this
where
that
is
coming
from.
So
this
very
much
could
be
it
right.
So,
let's,
let's
set
no
wrap
real
quick
so
that
it's
a
little
bit
easier
to
read:
simulate
open
tracing
and
instrumentation
on
a
sql
query,
so
we've
got
span
from
context.
A
A
A
Let's
see
here,
read
the
chat,
yeah,
sorry,
sorry,
everyone!
I
know
I
get.
I
get
so
focused
on
what
I'm
trying
to
fix
that
I
forgot
to
look
over
at
the
chat,
bigger
ui
list
of
traces.
It
opens
up
the
spans
yep.
That
makes
sense
a
b
and
c
are
spans
in
a
single
trace.
That
makes
sense
as
well
all
right.
So
when
you
use
span
from
context,
it
creates
a
span
using
the
span
from
the
context
as
its
parent,
so
they
become
part
of
one
trace.
That
makes
sense
right.
A
So,
if
you're
doing
span
from
context,
it's
probably
super
important
that
when
you,
when
you
set
up
this
span
inside
of
here,
it
obviously
needs
to
know
that
it's
going
to
be
part
of
this
overall
trace
right.
So
that
would
totally
make
sense,
not
sure
why
my
ui
keeps
flipping
out
on
me.
It's
like
I.
There
we
go
so
from
here.
A
A
Rpc
client
set
span,
okay,
well,
anyways,
I'm
probably
not
gonna
fully
grok
the
span
thing
in
just
today,
so
I
apologize.
But
what
I
was
looking
for
here
is
some
of
the
the
tag
details
and
things
that
it's
propagating
up,
so
my
my
gut
is
saying,
like
hey
we're
going
to
go
ahead
and
set
up
a
context
here,
let's
or
sorry
we're
going
to
set
up
a
span
here,
let's
bring
your
context
in
that
way.
We
can
correlate
it
to
the
trace.
A
Then
we
come
in
here
and
we
can
set
some
different
information
up.
That
will
give
us
things
like
these
tags
and
I
would
think
the
tags
are
propagating
inside
of
here.
So
if
we
go
to
my
sql
and
then
go
to
tags
check
it
out,
so
that's
the
tag
that
I
think
we're
we're
pushing
over
here
from
the
the
open
tracing
api.
A
A
A
Just
so,
I
can
wrap
my
head
around
it
for
next
time,
and
what
would
be
super
interesting
is
what,
if
we
could
morph
this
hot
rod,
app
to
use
some
of
the
open,
telemetry
apis,
because
then
we
can
learn
about
how
these
span
works,
how
we
instantiate
them,
how
we
work
with
them,
but
we'll
actually
be
looking
at
it
under
the
context
of
what
theoretically
should
be
the
new
api?
I
think
that
could
be
pretty
cool.
A
Let
me
let
me
know
and
chat
what
you
think
that
could
make
a
pretty
good
a
pretty
good
follow-up
here
for
getting
everything,
instrumented
and
working
together
and
check
chat,
while
we're
waiting
here
well,
also,
you
can
baggage
items
which
will
propagate
the
spans
down
the
trace
interesting.
I
like
that,
calling
them
baggage
items
and
kind
of
floating
them
downwards.
Okay,
interesting
cool
and
tags
are
metadata
on
a
span
exactly
yep
cool.
Well,
I
wasn't
expecting
us
to
spend
as
much
time
on
the
wiring,
but
I
learned
a
lot
of
stuff.
A
I
don't
know
about
y'all.
I
I
mean
obviously
very
very
cool
to
see
how
that
injection
works.
That
was
surprising,
but
I
think
we've
got
a
pretty
good
sense.
Now,
like
we
can
set
up
the
stack
right,
we've
got
the
operator.
We've
got
the
instantiations
of
them,
we're
able
to
hook
the
agent
up
and
start
pumping
the
data.
A
Actually,
I
don't
know
about
y'all.
I
think
this
is
again
because
this
is
a
topic
I'm
not
super.
I
don't
have
a
lot
of
expertise
in
so
it's
I've
learned
a
ton
and
my
brain
hurts
now.
So
I
think
with
that
it
might
be
time
to
check
chat
one
more
time
and
call
it
a
day.
So,
let's,
let's
see
what
y'all
are
saying
so
yeah,
it
seems
like
a
second
part.
We
all
kind
of
agree
on
seems
pretty
good
I'll
make
an
issue
in
github.
Just
so
we
don't
lose
track
of.
A
It
sounds
good
and
maddie
yeah
duffy,
I
don't
know
if
it's
duffy
and
george
or
who
it
is,
but
we're
working
on
figuring
out
how
to
do
multi-person
episodes
with
obs.
So
we're
super
interested
in
that
it
would
be
really
fun,
especially
with
chat
like
it'd,
be
great.
If,
while
duffy's
explaining
something
I
can
be
looking
over
chat
and
stuff,
I
think
it'll
make
you
all
feel
less
like.
Oh
my
gosh
josh,
we
gave
you
the
answer
a
second
ago,
which
I
totally
get
that'd,
be
killer.
A
All
right.
You
read
my
mind:
good
I'm
psyched
yeah,
so
hopefully,
in
short,
we
will
have
some
some
co-delivered
episodes
very
soon.
Can't
wait
go
on
for
the
episode
two
without
I
am
you
tracing
is
just
one
leg
of
open
telemetry.
That's
a
good
point
too
joe,
like
one
of
the
things
that
open
telemetry
covers
and
concerns
itself
with,
is
some
other
interesting
areas
too.
So
you
know
I
mean
heck.
Maybe
it
might
end
up
being
a
part
three.
I
don't
want
to
over
promise
in
next
episode.
A
I
just
have
a
feeling
that
we'll
pretty
easily
use
up
the
time
of
an
episode
if
we
do
just
a
tracing,
instrumentation
but
good
point
on
the
on
the
more
kind
of
multi-faceted
side,
so
cool
all
right
everyone.
Well,
it
was
a
pleasure
hanging
out
with
you.
I
hope
you
learned
something
those
of
you
who
helped
out
and
have
expertise
in
this
thanks
so
much
for
all
the
help.
As
always,
I
hope
you
all
have
a
killer
weekend
take
some
time
away
from
work.