►
From YouTube: Intro to PromQL with Julius Volz
Description
What is PromQL? Essentially the Prometheus Query Language, PromQL helps you slice and dice chosen data among a variety of other superpowers. In this clip from our series, Observability for What's Next, our Technical Writer Chris Ward is joined by Co-Founder of Prometheus, Julius Volz, to discuss the in-and-outs of PromQL, and its relationship to Prometheus.
A
B
B
I
was
back
then
responsible
for
coming
up
with
this
query
language,
which,
admittedly,
is
very
similar
to
the
query
language
of
the
borg
monitoring
system
at
google,
where
we
had
just
come
from,
but
still
has
you
know
plenty
of
its
own
functions
and
quirks
and
so
on
by
now,
but
yeah.
So
I
I
guess
I
can
say
I'm
the
the
creator,
the
original
creator,
at
least
off.
A
B
Bork
also
didn't
have
a
query
language,
but
it
kind
of
forms,
a
nice
kind
of
square
of
relationships
right
now,
borg,
inspired,
kubernetes
pokemon
was
used
for
monitoring
stuff
on
org
and
that
inspired
prometheus
and
prometheus.
Now
works
very
well
together
with
kubernetes
and
vice
versa.
So
there's
a
whole
and
they
both
have
these
greek
origin
names.
So
it
all
fits
very
well
together.
Okay,.
A
B
Ql
is
the
prometheus
query
language.
The
idea
in
prometheus
is
that
you
collect
a
lot
of
data
about
your
systems
in
the
form
of
time
series
before
you
do
anything
else,
and
then
to
do
anything
useful
with
that
data.
You
use
the
prom
qr
language
to
slice
and
dice
your
data
to
select
the
right
data
that
you
want
to
transform
it
to
aggregate
over
it
to
do
rate
computations
to
even
do
advanced
computations
between
whole
sets
of
time
series
like
arithmetic
between
whole
groups
of
numbers
that
match
together.
B
A
A
What
were
some
of
the
design
decisions
behind
prom
ql,
I
think
mostly
from
the
perspective
of
a
lot
of
people,
are
familiar
with
the
concept
of
a
query
language.
You
know
my
sequel
and,
and
things
like
that
in
in
quote,
unquote
traditional
databases.
So
why
was
the
design
decision
to
create
something
new
instead
of
leveraging
something
pre-existing.
B
So
I
think,
on
a
very
practical
level,
we
were
creating
prometheus
being
inspired
by
pokemon
and
we
had
worked
with
borgmon's
query
language
and,
admittedly,
prom
ql
is
quite
similar
to
what
pokemon
did
so
on
one
hand,
you
know
it
was
really
one
reason
was
being
inspired
by
that
and
not
having
to
invent
a
full
new
query
language
from
scratch.
Actually,
because
we
already
knew
one,
on
the
other
hand,
prom
ql
and
also
the
balkman
query.
Language
have
the
advantage
of
being
very
specialized
towards
time
series
computations,
especially
a
concept
in
there.
B
That's
called
vector
matching
where
you
can
do
binary
operations,
filter
operations
and
other
types
of
you
know:
operations
between
two
entire
sets
of
time,
series
that
have
corresponding
identities
so
same
label
sets,
and
these
operators
will
then
automatically
match
up
all
the
the
identical
label
sets
of
the
both
sides
of
the
operator.
Do
the
operation
between
them
and
give
you
results.
So
as
one
example,
for
example,
you
may
have
a
thousand
different
hosts
and
their
disk
usage
and
at
the
same
time
you
might
have
the
total
disk
size
for
each
of
these
same
thousand
hosts.
B
Then
you
could
take
those
thousand
numbers
on
one
side:
the
usages
divide
them
by
the
other
thousand
numbers
on
the
other
side,
the
total
disk
sizes
and
you
get
a
usage
ratio
out
of
that
and
the
binary
operator.
Does
this
automatic
vector
matching
between
the
left
and
right
hand,
side
which
is
like
almost
basically
automatic
in
prom
ql
and
allows
you
to
also
modify
it
in
certain
flexible
ways?
B
A
B
I
think
pretty
standard
systems
monitoring
ones.
You
have,
for
example,
counter
metric
that
tell
you
how
many
requests
a
given
service
is
handling
right
and
then
you
have
a
rate
function
to
calculate
the
rate
of
increase
of
such
a
counter,
whether
that's
requests
or
some
other
kind
of
event.
That
is
happening
in
the
system.
B
It
tells
you
a
rate
per
second
of
a
counter,
and
then
you
may
want
to
add
a
threshold
to
that
to
tell
you
like
if
certain
rates
are
too
high,
for
example,
error
rates
right
or
you
may
have
histograms-
that
tell
you
about
the
distribution
of
latencies
of
a
service
when
it's
handling
requests,
and
then
you
have
a
function
that
goes
together
with
that
kind
of
histogram
metric.
To
tell
you
approximately
what
a
90
or
95th
or
99th
percentile,
for
example,
would
be
for
those
request.
Latencies.
B
You
may
have
a
lot
of
these
queries
that
just
compute
ratios
or
sums
between
things.
Like
you
know
what
the
disk
usage
example
that
I
just
mentioned,
you
have
predictive
queries
that
would
predict
if
the
disk
is
going
to
run
full
in
one
day
based
on
the
last
four
hours
of
usage,
for
example,
and
so
on,
and
so
on.
So
you
know
basically
any
kind
of
constructs
that
would
help
you
monitor
the
request
rates,
error
rates,
latency
distributions,
utilizations,
saturations
and
so
on
off
your
services
and
systems
and
yeah.
B
B
But
then
you
also
have
people
just
using
prometheus
and
the
query
language
at
home
to
monitor
that
temperature
humidity
and
pressure
to
make
sure
that
the
dew
point
isn't
reached,
and
so
there
wouldn't
be
mold
in
there
in
their
bathroom
so
and
then
there's
other
people
who
use
it
to
monitor
their
wind
farms,
power,
output
and
rotation.
Angle
of
the
individual
windmills,
for
example.
B
So
quite
varied
works
pretty
well
for
all
kinds
of
systems,
monitoring
style
use
cases
that
you
have
for
any
numeric
data,
but
it's
important
to
note
that,
along
with
the
data
model,
which
only
you
know,
prometheus
only
stores
metrics
this
language
that
goes
along
with
that
data
model
also
only
works
on
metrics.
So
if
you
have
logs
traces
other
kind
of
signal
types,
you
would
need
to
have
a
different
system
and
a
different
language.