►
From YouTube: Better Logging in JavaScript - Ryan Kotzen
Description
console.log('Code got to here - 1083')
try {
// do something
console.log('Code got to here - 1084')
} catch (err){
console.log('Code got to here - 1085')
} console.log('Code got to here - 1086')
Have you seen this type of code before? Has this been your life at some point? Looking for a better way to figure out what's happening in your code and log important information? Well then, come join us for a as we explore how logging has evolved and how you can implement these concepts to make your life better!
Jozi.JS exists to try and foster a community in Johannesburg, a meetup group dedicated to all things JavaScript!
The group meets on the third Thursday of the month from 18:30 to about 20:30. There are typically two speakers, on different topics: a ‘lightning talk’ of 15 minutes and a full presentation of 45 minutes.
https://www.meetup.com/jozi-js/
A
Hey
everybody
thanks
a
lot
for
coming.
So
for
those
of
you
who
don't
know
me,
my
name
is
Ryan
Carson
I
am
a
software
engineer.
/
coach
/
do
a
little
bit
of
ops
type
things
and
also
a
bit
of
a
OpenShift
cluster
admin
at
the
moment,
so
just
to
show
you
that
life
and
you
can't
really
plot
where
you're
gonna
end
up.
But
today
I'm
going
to
be
talking
to
you
about
one
of
my
passions
and
that's
no
js'.
Although
this
the
talk,
the
principles
in
this
vlogging
talk
do
also
apply
to
the
browser.
A
So
for
those
of
you
who
aren't
working
in
ojs,
don't
feel
like
you
can
fall
off
to
sleep.
There
will
be
a
test
afterwards.
Also
the
concepts
apply
across
language.
So,
if
you're
unfortunate
and
you
have
to
work
in
java
or
slightly
more
fortunate
and
you've
got
some
c-sharp,
you
can
go
ahead
and
use
the
same
principles.
There.
Sorry
I'm
just
recovering
c-sharp
developer,
so
I've
got
some
nostalgia
for
it,
whereas
Java
I
just
have
horrible
horrible
memories,
cool
cool,
so
I
just
want
to
get
a
bit
of
a
idea.
What
people
are
working
on?
A
A
Anything
else,
no
Ruby
a
little
bit
of
Ruby
good
stuff,
keeping
it
real.
Okay
awesome.
So
what
are
we
gonna
do
over
here?
There's
no
slides,
I'm
gonna.
Take
you
through
some
code,
so
we
basically
are
going
to
look
at
how
we
can
do
logging
in
no
js'
or
on
the
server
side
and
we're
going
to
look
at
some
of
the
best
practices
for
it
and
specifically
a
node
which,
which
libraries
is
one
of
the
best
ones
to
use,
but
the
concepts
are
fairly
straightforward.
A
So,
just
to
give
you
some
background
when
I
first
started
developing,
you
know,
I
was
a
darknet
developer,
so
you
would
you
live
in
the
windows
world.
A
lot
of
this,
the
complexity
that
other
developers
have
to
deal
with
is
abstracted
away
from
you
until
about
three.
Four
years
ago,
I
didn't
even
realize
there
was
such
a
thing
as
standard
era
and
standard
out.
So
you
know
you
just
you
do
you,
you
go
to
Newgate
and
you
install
n
log
and
you
move
on
with
your
life.
A
The
logs
happened,
I
mean
you
know,
you
don't
know
why
they
happen,
but
you
know
they
happen.
So
my
journey
into
no
js'
sort
of
forced
me
to
realize
a
lot
of
like
what's
actually
happening
under
the
hood
over
there
and
for
those
of
you
who
might
not
be
familiar
and
not
not
ready
to
admit
it
on
any
any
operating
system.
A
There's
basically
two
streams
that
you
can
write
to
when
you
log
something
to
the
console,
that's
generally
standard
out
and
when
you,
when
you
have
like
some
sort
of
error
condition-
and
you
would
like
to
report
that
that
goes
to
standard
error
and
there's
all
sorts
of
mechanisms
on
the
actual
virtual
machine
or
Hardware
machine
that'll,
actually
allow
you
to
then
go
and
read
those
logs
and
report
on
them
and
figure
out
why
your
application
died
and
everybody
screaming
at
you
and
you.
You
can't
carry
on
drinking
on
a
Saturday
night.
A
So
for
those
of
you
who
are
sort
of
involved
in
the
more
operations
side
of
things,
not
just
listen.
Necessarily,
the
dev
you'll
know
that
when
there's
a
crisis-
and
you
need
to
get
at
your
logs
to
figure
out
what's
gone,
horribly
wrong
if
you've
got
like
eight
machines,
all
running
a
same
version
of
your
app
and
you
have
to
SSH
or
Remote
Desktop
into
each
one,
to
try
and
read
the
logs
off
of
the
Event
Viewer
or
on
the
file
system
somewhere,
it's
an
absolute
nightmare
and
that
just
prolongs
the
suffering.
A
It's
not
so
much
of
an
issue
when
you're
actually
doing
the
dev,
because
you've
got
your
console
and
there's
generally
only
in
one
version
of
the
application
up
and
running.
So
you
might
not
be
from
any
of
those.
But
if
you
are
administering
any
sort
of
testing
environment
as
well,
where
you
need
to
do
performance
management
or
investigate
issues
that
are
happening
in
the
test
environment.
This
will
also
apply
to
you.
So
today
take
a
look
at
that.
A
A
A
If
you
are
running
on
production
without
anything
extra
added
to
just
show
you
how
that's
all
working
we've
just
got
a
simple
map
over
here
array
with
map
objects
that
we
can
loop
through
and
we're
using
in
a
really
cool
little
library
called
enquirer,
which
allows
you
to
do
console
app.
So
if
you
find
that
you're
adding
lots
of
little
tools
to
administer
your
systems
and
you
and
you
like
the
command-line
go
ahead
and
install
that
the
other
thing
we're
using
is
env
which
allows
us
to
reload
environment
variables.
A
A
Also,
if,
at
any
point
during
this
talk,
you've
got
any
questions
feel
free
to
shut.
Stop
me
put
up
your
hand,
get
a
bit
of
a
discussion
going
and
we
can
see
if
we
can't
address
any
of
those
concerns
cool
so
that
that
standard,
console
and
error
logging
is
fairly
straightforward.
It's
fairly
powerful,
but
if
we're
going
to
be
running,
multiple
systems
in
production
and
you've
been
reading
a
lot
up
on
the
hacker
news
and
you've.
You've
decided
that
micro
service
is
really
awesome
and
it's
gonna
solve
the
problem
that
you
have.
A
That
problem
is
going
to
become
even
even
more
crazier
to
try
and
figure
out.
Okay.
Well,
a
web
request
came
in
and
then
it
went
through
all
of
one
of
these
60
different
micro
services
and
what
was
the
actual
journey
that
that
web
request
took
before
it
got
swallowed
up
and
died
so
investigating
that
without
a
central
logging
system
can
be
in
apps
Nightman.
So
one
of
the
most
popular
at
the
moment,
logging
frameworks
for
nodejs,
nodejs,
being
quite
popular
in
micro
services,
is
called
Winston.
A
Anybody
here,
using
Winston
cool
we've
got
a
few
people
using
it
good
stuff.
So
Winston
is
just
an
NPM
package.
We
install
it
the
way
we
would
any
other.
You
can
set
up
a
bunch
of
different
levels
and
you
can
do
cool
colors
so
that
you
can
make
your
console
a
little
bit
more
easier
to
read.
You
want
to
pick
up
the
error
in
red.
Obviously,
you
can
also
write
those
to
file,
but
the
file
reader
that
you're
looking
at
has
to
support
those
unicode
colors.
A
So
I've
just
set
up
some
basic
code
because
I'm
going
to
be
sharing
a
hell
of
a
lot
of
it
between
the
different
examples.
So
if
colors
they're
using
typical
strings
I'm,
not
sure
if
hash
codes
are
supported,
then
we've
got
the
different
levels
of
errors.
Error
levels
are
quite
quite
useful.
They
allow
you
to
filter
based
on
where
the
logs
are
going
to
go
so
you're
gonna,
say
honest,
send
all
of
my
trace
logs
here,
or
everything.
A
Trace
and
above
I
want
to
send
there
and
everything
that
is
error
or
fatal
I
want
it
to
send
to
my
Twitter
feed
so
that
I
can
pick
it
up
pretty
quickly.
You
know,
so
you
can
do
some
some
interesting
things
with
log
levels
over
there
and
then
I've
got
a
simple
file
over
here,
which
is
going
to
log
some
stuff
for
us.
So
we've
got
a
moviestar
JSON
file
that
we're
just
loading
up
fairly
complicated
well
fairly.
A
Straightforward
objects
just
to
see
how
the
different
options
are
going
to
handle
that
and
we've
got
some
strings
over
there
with
I'm
a
fatal
or
whatever.
The
level
happens
to
be
at
that
point
in
time.
So
just
going
back
over
here
we
will
call
Winston,
we'll
add
the
colors
to
it,
and
then
we
will
set
up
the
log
levels
and
we
will
import
the
log
stuff
module
and
from
there
we
will
instantiate
a
new
instance
of
the
Winston
logger,
with
all
the
various
options
that
you
can
pass.
They
are.
A
There
was
recently
an
update
from
Winston
to
point
X
to
three
point:
X,
a
major
version
update
if
you
are
running
this
in
your
project,
make
sure
you
look
at
the
right
documentation
because
it
has
changed
quite
substantially
and
that
cost
me
at
least
an
hour
of
life
while
putting
it
together
these
lights
and
then,
lastly,
we
will
call
log
stuff
and
we
will
pass
in
the
Winston
logger
cool.
So
let's
take
a
look
and
see
what
that
looks
like.
A
You
can
turn
that
off
if
you
want
actually
like
proper
Jason,
which
becomes
quite
important
a
little
bit
later,
Cooke
so
logging
to
console
we've,
we've
increased
our
console
visibility
by
adding
some
colors
and
some
timestamps,
but
we
still
have
to
log
on
to
every
box
to
try
and
figure
out
when
something's
gone
horribly
wrong.
So
the
next
step
we
might
want
to
do
is
log
to
a
filesystem.
That
way
we
might
write
some
sort
of
parser
that'll,
pick
up
all
the
logs
on
the
filesystem
and
send
them
to
a
central
place.
A
It's
called
log
shipping.
So
in
order
to
do
that
in
Winston,
it's
fairly
straightforward,
we
just
add
a
different
transport
and
Winston
has
all
sorts
of
different
transports
that
you
can
hook
in.
Depending
on
what
data
store
you
might
want
to
send
your
logs
to,
in
this
case,
we're
using
a
file
one
there's
MongoDB,
there's
a
Redis
one
elasticsearch
and
a
few
others.
So
setting
up
a
file
log
is
fairly
straightforward.
A
So
if
we
do
fire
logging,
we'll
all
we'll
see
is
that
it's
written
two
logs
era
which
I
probably
should
have
cleared
so
that
you
guys
would
believe
me,
but
there
should
be
a
timestamp
in
there.
So
there's
our
time
and
you'll
see
that
it's
logged
the
the
logs
in
a
JSON
format.
You
can
actually
control
what
format
it's
going
to
do
and
if
it's
going
to
include
the
colors
inside
your
file
as
unicode
backtick
things
not
backtick,
sorry
unicode
escaped
characters,
which
is
quite
useful.
Now
a
lot
of
the
time.
A
A
Let's
clear
that
out:
oh,
we
set
a
level,
so
movies
go
through
the
log
or
debug,
and
if
we
look
at
the
code
we
said
over
there
and
the
levels
is
equal
to
levels.
So
then
that'll
actually
set
up
the
levels
and
trace
and
then
for
file
logging.
So
we've
overridden
the
default
trace
level
and
we've
said
only
warning.
Messages
should
go
to
file
because
we
don't
care
about
trees,
but
we
could
easily
just
go
ahead
and
change
that
to
trace
actually
choose
the
option.
A
Write
those
two
files
and
you'll
see
those
get
serialized
again
as
a
JSON
object.
Although
it
looks
like
there
is
a
JSON
object,
but
you
only
actually
get
one
in
total
and
I
can't
figure
out
how
to
scroll
to
the
right.
At
the
moment.
I
don't
know
where
my
scroll
bar
is
that
it
helps
if
you
turn
the
monitor
to
the
right
size.
So
you'll
see
it's
actually
not
nested.
The
JSON
object
inside
the
JSON
objects.
It's
just
flatten
the
properties
which
is
not
ideal.
A
So
you
might
want
to
tweak
that
option,
but,
like
I
was
saying
you
might
want
to
log
to
the
file
as
well
as
to
the
console,
and
so
we
here
we've
got
our
file,
our
console
logging,
and
if
we
look
in
the
error
log
you'll
see
after
then,
we've
got
our
warnings
and
above
cool,
and
if
we
look
at
the
code
for
that,
it's
actually
fairly
straightforward.
It's
a
combination
of
the
previous
two
codes,
the
transports
take
in
an
array
you
can
put
as
many
of
those
as
you
need.
A
So
the
next
thing
that
we
we
tend
to
do
on
our
evolution
of
how
we
write
our
logs
is,
we
might
want
to
save
them
to
our
database.
Now,
a
very
important
thing
when
saving
logs
to
your
database
is
don't
save
your
logs
to
the
same
database.
That
is
your
production
database,
because
what
happens
is
if
you?
A
Firstly,
if
you
can't
connect
to
your
database,
you
can't
write
your
logs
and
you
can't
figure
out
why
you
can't
connect
to
your
database
and
secondly,
if
you're
you've
got
some
code
that
causes
an
infinite
loop
of
logging
messages
to
go
into
your
database
you're,
going
to
fill
that
thing
up
pretty
quickly
and
that's
going
to
end
up
in
an
actual
production
error.
So
your
trace
logging
could
cause
a
prod
error
because
of
that
so
be.
Very
careful.
A
Mongodb
is
pretty
good
for
this
sequel,
not
as
much
because
it's
it's
structured
data
and
you
don't
necessarily
need
you
know
a
dev
time.
What
the
log
message.
Let's
say,
if
you're
logging,
a
Java
Script
object,
you
don't
necessarily
know
the
properties
that
are
gonna
exist
on
that
object,
but
being
a
schemas
database
is
fairly
straightforward.
A
A
If
you
can
get
get
your
company
to
pay
for
him,
it's
pretty
cool.
So
here
we've
got
some
log
messages.
You
can
see
the
timestamp
and
this
is
pretty
cool
because
we
can
now
start
to
aggregate
our
logs
from
the
different
places.
Obviously,
the
servers
need
to
be
able
to
see
the
MongoDB
server,
so
your
network
segmentation
becomes
fairly
straightforward,
but
we
can
do
some
interesting
stuff.
So
you
know
in.
A
A
So
we
can
go
and
run
that
query
and
we
can
just
get
the
errors
out
of
there
that
you
can
then
say
where
the
level
is
error
or
equal
to
fatal,
because
you
know
generally,
you
want
to
get
those
together
and
you
can
start
start
saving
those
queries.
You
can,
even
if
you're
super
adventurous
bill
to
react
app
on
top
of
your
MongoDB
to
just
look
into
your
logs.
Don't
do
that,
there's
actual
stuff
out
there
that
you
can
just
install,
but
if
you're
crazy,
you
can.
A
No,
it
doesn't
that's
the
beautiful
thing
about
storing
it
to
so.
If
we
take
a
look,
it
looks
like
a
database
record.
So
if
I
remove
this
filter,
it
looks
like
we've
got
a
whole
bunch
of
database
make
records
over
here,
but
let's,
let's
go
ahead
and
delete
those
and
actually
dump
dump
an
actual
complex
object
into
there.
So,
let's
put
the
traces
into
the
database
cool,
that's
done
rerun
our
query
and
you
will
see.
We've
got
some
over
here
with
a
message
now.
A
If
you
look
at
it
and
you're
used
to
seeing
a
sequel
table,
you're
like
well,
the
message
is
blank,
but
actually,
if
we
go
ahead
and
show
the
embedded
fields
well,
there's
a
few
different
ways.
You
can
look
at
it.
So
this
is
the
table
view.
There's
the
tree
view
which
will
show
you
okay.
Well,
we
can
expand
this
tree
and
dig
a
bit
down
and
there
you
can
actually
see
the
object
and
then
there's
the
actual
closest
to
what
is
actually
doing,
which
is
the
JSON
view
and
you'll
see
here.
A
This
is
what
it's
actually
storing
in
the
datastore.
We've
got
a
nested
object
and
because
that's
just
js
well,
it's
technically
beasts
on
which
is
binary
by
narrowly
serialized
object,
notation,
which
basically
will
store
that
object,
instead
of
as
a
string
which
is
not
super
efficient
as
binary,
and
we
can
see
the
the
nested
fields
all
get
included
over
there,
which
means
we
can
then
query
on
them.
A
But
then,
if
your
data
is
unstructured,
it's
kind
of
hard
to
know
which
query
which
indexes
to
put
on
but
you're
sort
of,
as
you
maintain
a
production
system,
you'll
get
a
feel
for
what
your
data
is
looking
like
and
what
you
tend
to
query
on
and-
and
you
know
you-
you
try
and
say,
if
Saturday
night
Ryan
some
time
by
building
these
queries
ahead
of
time,
cool
but
MongoDB,
while
a
great
document
store
is
not
necessarily
designed
for
logs.
It's
it's
fairly
fairly
useful.
A
One
thing
that
I
see
a
lot
of
people
doing
is
upsetting
their
logs
up
so
that
if
an
error
occurs,
they
get
an
email.
So
the
intent
is
good,
but
generally
that
shouldn't
be
a
requirement
of
your
actual
code
to
push
that
through
to
email,
because
you
kind
of
want
to
set
up
alerts
around
things
that
are
not
errors
as
well.
So
if
we
get
10
warning
messages
in
under
a
second
send
an
email,
but
maybe
not
for
every
single
warning.
This
and
there's
a
whole
bunch
of
frameworks
and
third-party
software
like
la
Glee.
A
It's
one
that
I
used
in
startup
that
I
was
working
with
it's
very
cool
because
you
can
set
up
all
sorts
of
queries
and
then
based
on
certain
conditionals,
say
fire
off
an
alert
and
an
alert
can
then
have
different
endpoints
but
oftentimes.
We
just
have
an
SMTP
server
and
we
want
to
pipe
some
data
through
there.
A
A
So
for
whatever
reason,
the
email
logging
works
perfectly
in
Windows,
but
trying
to
run
it
in
a
bun
do
results
in
an
error,
but
it
does
actually
connect
through
to
the
SMTP
service
as
we'll
see
in
the
log
messages
over
here,
or
sometimes
it
doesn't
so
you
can
see
like
it's
invoking
the
SMTP
server
and
then
saying
that
a
con
connected
so
I
figured
that
out
just
before
this
demo.
But
you
can
trust
me
if
you
load
it
up
in
Windows,
you
get
an
SMTP
thing
written
to
the
disk.
A
I
think
it
has
something
to
do
with
log
levels.
Sorry
permissions
in
in
in
a
Linux
based
filesystem,
you
can
see
that's
owned
by
root,
but
I'm
running
it
as
root
and
the
other
thing
doc
is
running
is
root,
so
it
should
have
worked,
but
it
doesn't
anyway,
like
I
was
saying.
Logging
to
email
is
generally
not
a
great
practice.
You,
you
kind
of
want
a
layer
of
abstraction
on
top
of
when
an
email
gets
sent
out,
so
you
can
do
a
bit
more
complicated
stuff.
A
Another
anti-pattern
I
often
see
with
people
and
doing
email
based
logging
for
the
errors
in
their
warnings.
Is
they
create
an
Outlook
rule
and
put
all
of
the
errors
and
warnings
into
a
file
in
there
in
the
email?
And
then
it's
like
well,
what
was
the
point
of
that,
because
you're
only
checking
that
every
now
and
then-
and
you
know,
if
you
look
at
how
we
are
moving
in
terms
of
productivity,
a
lot
of
times
like
I'll,
only
have
my
email
open
once
a
day.
A
So
email
becomes
not
such
a
great
mechanism
for
picking
up
those
sort
of
errors,
but
there
are
a
lot
of
people
who
who
find
it
very
useful.
So
then
we
we've
got
the
sort
of
rolls-royce
of
logging
and
that's
the
elastic
stack
previously.
The
ELQ
stack.
Has
anybody
here
worked
on
that
before
oh
gosh,
so
you'll
know
if
I'm
all
right?
Well,
there
we
go
so
elastic
stack
is,
is,
is
a
really
great
way
to
store
your
log
messages?
It's
also
got
a
lot
of
really
awesome.
A
Other
applications
like
text
searching,
did
anybody
here
useless
seen
back
in
the
day,
so
if
you've
got
an
MS
sequel
database
and
you
got
like
books
or
other
products
that
you're
storing
and
you
want
to
do
some
text
analysis
on
the
descriptions.
So
that's
your
search
actually
results
in
your
customers.
Finding
your
products,
the
scene
was
the
absolute
best
for
that
back
in
the
day,
I'm,
not
sure
if
it's
still
in
use,
you
guys
can
get
in
there
talk
to
that,
but
it
does
really
really
interesting
things
with
engrams
and
other
text
mechanisms.
A
So
an
Engram
is
basically
when
you
take
a
word
and
you
break
it
up
into
its
consistent
constituents.
So
if
I
open
up
a
notepad
and
we
say
test
and
when
you
break
it
into
a
four
Engram,
it's
test,
3m
Graham
is
tests
and
then
est
sorry.
That
bracket
should
be
over
there.
What
not
there
so
each
of
the
components
looks
kind
of
like
that,
and
then,
if
we
break
it
into
a
two
gram,
you
know
you
get
two
es
SD,
that
sort
of
thing
and
that
allows
you
to
then
index
each
of
those.
A
So
while
a
person
is
typing,
you
can
do
type
a
heads
with
a
single
look
up
as
opposed
to
a
contains
or
it
starts
with,
or
it
ends
with
and
then
edge
Engram.
You
basically
just
take
out
the
ones
that
are
not
there
and
that's
how
a
lot
of
the
text
searching
on
sites
like
Amazon
in
that
time
type
of
thing
work.
But
what
does
this
have
to
do
with
logging?
You
know
that
sort
of
comes
later.
A
First,
we
have
to
get
our
data
into
elastic
search
so
that
we
can
actually
start
doing
all
of
this
analysis
on
it.
So
the
elastic
stack
is
made
up
of
a
few
components,
the
first
one
being
elastic
search
and
that's
where
the
data
then
there's
different
ways
of
getting
your
data
into
elasticsearch
before
it
was
logstash
now
they've
got
the
beats
libraries
which
they've
got
a
bunch
of
different
heartbeat
type
things.
So
you
can
send
your
cpu
memory
all
of
that
on
a
heartbeat
in
to
log
into
elastic
stack.
You
can
also
do
log
shipping.
A
So
if,
for
whatever
reason
you
can't
directly
or
you
don't
want
to
write
all
of
your
logs
directly
to
elastic
sack,
you
can
write
them
to
the
file
system
and
then
you
can
ship
them.
So
you
can
say,
like
every
30
seconds,
send
the
logs
across.
So
that's
that's
great
for
existing
applications
where
you've
lost
the
source
code,
but
it's
mission-critical
and
you
kind
of
it's
writing
to
the
file
system
and
you
need
to
send
those
logs.
A
So
you
can
actually
see
what's
going
on,
so
you
can
use
the
the
full
stack
for
that
and
then,
on
top
of
it,
they've
got
a
visualization
tool
called
cabana
and
cabañas
a
GUI
based
analyzer
or
visualizer
for
your
logs.
If
you
have
got
the
paid
full
version
of
cabana,
you
can
actually
then
also
set
up
the
rules
and
the
alerts
and
how
they
actually
will
notify
you.
So
you
know
you
can
plug
in
your
your
Twitter
feed
again
or
whatever.
It
is
that
you
need
in
order
to
get
notified
at
the
appropriate
time
cool.
A
So
in
our
docker
compose
file,
we
set
up
elasticsearch
running
on
a
specific
machine
IP
well
in
this
case
it's
localhost
and
on
a
port,
and
we
inject
a
super-secret,
password
and
username
combination
for
us
to
access
it.
And
then,
if
we
go
to
our
browser,
we
will,
if
we
visit
that
URL
if
I
close,
that
is
it
going
to
stop
costing
okay.
A
So,
let's
just
go
and
take
a
look
at
that
we
node,
so
we
don't
stuff
into
elasticsearch
I've,
had
to
put
in
a
bit
of
a
wait
time
and
to
make
sure
that
it
flushes,
because
if
it's
running
in
memory
you
know
what
it
does
is
it
sends
them
in
batches,
as
opposed
to
each
log
message
to
to
fix
the
the
latency,
not
the
latency,
to
make
sure
that
you're,
not
sending
thousands
of
requests
into
your
log
serve
at
one
time
so
again
we're
using
Winston
to
do
that.
What
we've
done?
A
We've
created
an
elasticsearch
client
using
the
elasticsearch
library,
and
we
passed
that
client
in
to
the
Winston
transport
as
it
expects
it.
So
all
of
the
rules
for
how
to
do
authentication
and
that
sort
of
thing
are
stored
in
the
client
and
we
just
set
up
the
rules
for
how
our
logs
are
gonna
work
over
there
and
then
we
log,
stuff
and
you'll
see
I've
got
my
supers
hacky,
set
time
out
of
5
seconds
to
make
sure
that
the
the
the
stuff
actually
gets.
A
Flushed
I
tried
setting
the
flash
interval,
but
not
not
not
a
hundred
percent
sure.
Why
that
didn't
work
so
well,
so
we've
now
dumped
some
stuff
into
elasticsearch,
but
how
do
we
actually
query
it?
So
for
those
of
you,
who've
worked
with
elastics
they're,
the
elasticsearch
you'll
know
that
there's
a
RESTful
API,
but
it's
written
by
a
bunch
of
developers
who
don't
really
understand
rest.
So
there's
a
lot
of
anti
RESP,
there's
a
lot
of
anti
rest
patterns
that
they've
used.
But
you
know
it's
it's
it's
a
standard
now,
so
it's
okay
right!
A
So
anyway
we
got
this.
This
is
postman
for
those
of
you
who
might
not
be
familiar
with
it
really
awesome
tool
for
checking
out
rest
stuff
testing,
your
REST
API
s,
so
we
saw
like
we
saw
in
the
browser
we
can
get.
If
we
just
go
to
the
root,
we
can
get
back
some
information
about
the
server
we
can
get
a
list
of
indexes.
A
So
we've
got
a
bunch
of
back
on
zoom
in
at
this
point,
but
you
can
actually
see
there's
my
awesome
app
over
there
and
what
you'll,
what
you'll
have
in
elasticsearch
is
it's
not
completely
schema
lists
like
MongoDB.
There's,
a
mapping
and
a
mapping
can
have
a
property,
that's
an
object,
and
that
part
is
schema
this.
But
you
kind
of,
if
you're
going
to
be
doing
a
lot
of
searching
on
your
data.
You
want
to
set
up
these
mappings
so
that
it
actually
allows
you
to
to
do
those
queries
in
an
efficient
way.
A
So
if
you
do
not
set
a
mapping,
it
will
set
a
mapping
for
you
and
you
cannot
change
that
mapping
without
dropping
and
recreating
the
index.
So
you
might
want
to
go
through
a
bit
of
trial
and
error
on
dev
before
committing
to
a
final
mapping.
It's
just
JSON,
so
we
can
see
over
here.
There
are
some
properties.
We've
got
a
timestamp
aversion,
some
fields
we
might
want
to
store
and
there's
all
sorts
of
data
types
and
rules
around
them.
A
You
can
tweak
these
to
do
like
really
really
powerful
searches
later
on,
like
the
lysene,
text-based
indexing
and
and
that's
some
of
them,
the
really
powerful
things
about
elastic
search.
But
if
you
are
just
using
it
for
your
log
messages,
you
don't
have
to
get
too
fancy
with
that.
You
can
then
search
through
a
mapping
using
a
center
of
the
the
the
query
syntax
that
they
provide
and
there's
also
the
lysene
syntax
is
supported
on
cabaña.
A
B
A
They've
they'll
underscore
it
so
you'll
get
underscore
underscore
type,
but
maybe
not
cool,
and
then
you
can
also
do
a
search
through
a
post
with
the
body
and
a
query
rather
than
a
query
string,
and
that's
that
same
syntax,
we'll
see
later
on
in
Cabana,
and
then
you
can
also
do
some
interesting
things
like
subfields,
so
you
can
search
where
field
dot
a
dot,
B
dot.
Z
is
equal
to
this
or
starts
with
this
or
partially
matches.
There's
all
sorts
of
very
interesting,
syntax
things.
We
can
do
with
that
cool.
A
A
You'll
see
this
is
the
first
thing
that
it
presents
you
with.
We
haven't
we're
not
currently
tracking
any
of
the
indexes
that
exist
within
elasticsearch.
You
should
tell
us
which
one
to
call
to
to
start
tracking.
So
if
we
look
at
our
app,
we
are
prefixing
all
of
our
logs
with
awesome.
App,
so
you'll
see,
there's
an
index
pattern
over
here
where
it's
got
a
standard
wildcard,
so
we're
seeing
any
logs
that
belong
to
awesome
app.
We
want
to
see
them
together
and
we
can
create.
A
Well,
there's
a
lot
of
system
indexes.
So
if
we
look
at
the
indexes
that
are
included
by
default,
get
all
indexes,
there's
a
monitoring
es
6
triggered
watches
monitoring,
Cabana
watch
a
history,
Cabana
watches.
So
if
you
did
that
you
would
probably
get
a
bunch
of
false
positives
in
your
log
messages,
yeah
and
then
what's
gonna
happen
is
the
guy.
Next
to
you
is
gonna,
be
like
oh,
my
gosh.
That's
so
cool
I
want
to
put
my
applications
logs
in
in
Cabana,
but
I
don't
have
a
server.
A
A
So,
if
you've
got
bas
on
your
team,
who
want
to
get
some
some
useful
analytics
out
of
it
or
data
scientists,
or
maybe
you've
just
got
an
interest
in
that
yourself,
you
can
go
ahead
and
do
that
so
there's
a
discover
feature
over
here
where
you
can
pick
of
a
specific
index
pattern
that
you've
you've
previously
saved
and
you
can
sort
of
see
okay.
Well,
what
in
the
last
15
minutes
you'll
see
over
there
you?
What
are
the
log
messages
that
are
currently
in
the
system?
A
And
you
can
say
okay
well
in
the
last
15
minutes.
These
are
the
messages
and
they've
got
these
fields
on
them
and
you
can
use
the
lysene
query
syntax,
which
some
of
you
might
be
familiar
with
from
Lucene
to
actually
go
ahead
and
do
text
searches
which
is
slightly
different
from
how
we
do
the
searches
on
the
rest
side
of
things
and
there's
a
whole
little
guide
that
you
can
go
to
and
plugged
into
the
internet
and
that'll
tell
you
like.
You
know
how.
How
can
you
do
that?
How
to
do
that?
A
But
you
know
searches
on
standard
text,
so
you
can
find
the
errors
in
your
system,
which
is
generally
what
you
want
at
12
a.m.
on
a
Saturday
and
you'll,
see
there's
the
fields
over
here,
so
you
can
actually
add
them
and
say
like
well.
I
want
to
look
at
that
based
on
this
and
you
remove
them
so
you're
like
okay.
A
Well,
let's
take
a
look
at
the
genres,
so
here's
a
log
message
with
a
genre
of
which
means
you
probably
want
to
log
a
ticket
with
your
developers
and
say:
hey,
stop
blogging
genre
of
when
there's
no
genre
just
use
an
empty
array,
and
you
know
you
might
want
to
then
go
ahead
and
add
also
the
titles
of
the
movies
to
sort
of
figure
out
how
those
relate
to
each
other.
There's.
Also,
the
very
cool
visualizer.
A
This
interface
has
changed
quite
significantly
between
version
5
and
version
6
of
qivana.
In
version
5,
you
got
the
alerts
and
everything
for
free
in
version
6
they're
trying
to
upsell
you.
So
there's
a
lot
more
fancy
stuff,
but
you
need
to
you
need
to
pay
for
the
alerts,
and
you
know
you
can
go
through
these
and
you
can
click
on
like.
Let's
make
a
pie,
chart
I,
never
remember
the
syntax,
for
this
I'm,
probably
going
to
figure
it
out
on
a
specific.
A
Genre
keyword
based
on
the
count,
add
sub
buckets
now,
anyway,
you
can
play
around
at
the
visually
in
your
own
time.
That's
left
as
an
exercise
for
the
reader,
and
you
can
do
some
really
interesting
things.
Once
you've
made
those
graphs,
you
can
pull
them
into
a
specific
dashboard,
so
you
can
create
like
a
dashboard
for
your
CEO
and
a
dashboard
for
your
bas
and
a
dashboard
for
you
on
a
Saturday
night.
A
So
you
can
then
go
in
and
drill
down,
there's
timeline,
which
basically
is
a
timeline
uh-huh
of
all
the
things
that
happen
in
your
log
messages,
so
you
can
basically
see
when
things
are
coming
in.
You
can
do
response
times.
There's
a
machine-learning
button,
I've
clicked
it
I,
haven't
yet
understood
machine
learning,
so
it's
obviously
broken.
Maybe
they'll
fix
it
in
the
next
patch.
You
can
do
interesting
things
with
the
graphing
in
the
dev
tools,
so
you
can
add
those
patterns
in
there
and
yeah
so
like
we
saw
where
we
posted
through
a
body.
A
You
can
also
type
your
queries
here
and
the
nice
thing
about
typing
them
here.
So
you'll
see
there's
a
query
where
the
field
title
matches
phrase
star.
So
if
we
run
that
we
get
back
a
total
of
four
hits,
we
get
back
Star,
Wars,
Episode,
six,
seven
Star,
Trek,
Star
Trek
beyond,
because
we've
posted
through
duplicate
messages,
and
you
can
actually
over
here
you
get
some
sort
of
intellisense,
which
is
quite
useful
as
well,
which
you
don't
get
in
postman.
So
this
is
pretty
cool
and
you
can
then
build
through
build
your
queries
on
here.
A
A
You
know,
so
what
you're
doing
is
you're
tying
up
your
application
thread
dealing
with
logs,
so
what
you
should
actually
be
doing
is
go
back
to
what
we
started
with
in
the
beginning,
right
things
to
stand,
it
out
right
things
to
standard
error
and
use
a
pipe
and
pipe
it
to
P.
No
and
P
Noah
can
then
take
care
of
it.
So
we'll
take
a
look
at
that,
so
you
can
use
P
know
in
a
very
similar
way
to
how
Winston
works.
A
So
here
this
will
basically
just
give
you
the
pretty
print
and
that
sort
of
thing
so
we've
got
some
JSON
over
there
and
we've
got
some
colorized
error
messages
at
the
top
over
there,
so
P
know
is
great
by
default.
It
just
writes
to
standard
output
and
standard
error.
The
the
very
powerful
with
P
know
is
instead
of
transports
that
live
inside
your
app.
You
just
simply
use
UNIX
and
unix-like.
A
A
We
can
there
and
I
don't
want
to
do
that.
I
wanted
to
NPM
Ron,
no
stupid,
touchpad,
NPM
Ron
pipe.
What
that'll
do
you
see?
It's
the
rights
out
to
the
console
so
great
when
you're
debugging,
but
on
your
production
server
it's
going
to
or
on
your
production
application
server
it's
going
to
pipe
those,
so
the
nodejs
thread
can
now
continue
doing
your
business
logic,
where,
as
a
new
operating
system
thread,
will
then
pick
that
up
and
ship
those
off
for
you,
the
other
great
thing
of
our
pino
is.
A
A
Load
some
graphs,
so
just
from
a
philosophical
standpoint,
you
know
if
you
are
running
a
c-sharp
application
and
you've
got
thread
pooling
and
all
of
the
the
other
interesting
things
you
don't
have
to
worry
about
that.
So
much.
But
you
know
the
great
part
about
nodejs
is
its
non-blocking
I/o,
which
you've
now
blocked
by
doing
the
logging.
A
So
also,
if
you
are
running
your
node
application
in
something
like
PM,
2
or
forever,
you
know
you
want
your
application
to
boot
up
pretty
quickly
in
case
it,
because
so
you
can
scale
it
nicely,
let's
get
it
up
and
down.
So
it's
got
the
little
graphs,
no
I
think
it's
on
the
github
page,
because
a
comparative
advertising.
So
yes,
that
is
logging
in
no
js'.
But
what
about
the
browser?
How
much
time
do
we
have
so
with
browser
with
the
with
the
browser?
You've
got
some
options.
A
Pino
actually
has
a
browser
version,
so
you
can
ship
those
off
to
your
elasticsearch
server
if
it
is
Excel
externally
accessible.
If
it's
not,
you
might
want
to
write
a
little
node
proxy,
simply
send
that
rest
request
through
to
your
node
proxy
and
then
dump
it
into
into
elasticsearch
from
there
or
MongoDB
or
your
filesystem.
So
we
were
writing
a
react
native
application
and
the
Android
logging
is
not
so
but
great,
it's
hard
to
actually
tie
up
a
workflow
to
an
actual
log
message.
A
So
what
we
actually
did
is
we
hooked
into
the
we
use
some
monkey-patching
hooked
into
console
dot
log
and
we
shipped
all
of
those
log
messages
across
there's.
You
know
a
lot
of
your
gut
instinct
when
you
look
at
monkey-patching
consult
at
logs,
so
that
you're,
for
those
of
you,
don't
know
about
monkey
patching,
you
can
actually
override
the
default
console
dot.
Log
keep
a
reference
to
what
it
used
to
be
add
your
own
code
and
then
call
what
it
should
be.
So
you
know
some
people
might
not
feel
comfortable
with
that.
A
But
if
you've
got
somebody's
node
package
manager,
a
node
module
that
you've
installed
via
NPM,
they
might
have
used
console
dot
log
inside
there
and
that
information
might
be
relevant
just
before
the
error
that
you're
getting.
If
you
write
your
if
you
instantiate
your
own
logger
and
only
send
those
log
messages
across
to
your
aggregated
logging,
you
might
miss
that
information
so
overcome
your
fear
of
monkey
patching
and
just
go
ahead
and
do
it
so
here's
the
peano
page
and
if
we
winds
winds,
benchmarks
for
Winston,
they
had
graphs
the
other
day
anyway.
A
We'll
look
at
the
text
so
benchmarks
for
P
no
dot
info
HelloWorld.
You
can
see
with
Winston
quite
slow
two
seconds,
whereas
with
Pino
two
hundred
and
sixty
nine
milliseconds.
So
if
you
believe
the
hype
and
I've
seen
it
in
a
production
app,
it
sped
it
up
quite
a
lot
at
least
shaved
off
at
least
ten
seconds
from
the
boot
up
time,
which
was
an
app
that
was
connecting
to
and
establishing
sort
of
a
network
cluster
thing
going
on
cool.
B
B
B
A
Kind
of
the
same
way
that
I
do
two
in
the
browser
or
in
the
client
I
it's.
It's
called
a
correlation
ID.
So
if
you're
in
HTTP
world
and
sending
a
rest
request,
there's
a
specific
header
for
it,
it's
X
correlation
ID.
So
before
you
create
the
request,
what
you
would
do,
is
you
construct
the
good?
You
know
using
you,
you
ID
or
some
sort
of
library,
so
you
make
a
good
and
you
assign
it
to
that
request,
and
that
request
then
goes
to
the
server.
A
When
it
comes
back,
you
can
sort
of
tie
the
two
up
as
well
anyway,
if
you've
got
like
a
microservices
architecture
or
some
sort
of
distributed
architecture,
you
can
follow
it
based
on
that
correlation
ID,
because
it's
unique,
if
you
have
multiple
workers
for
each
job,
you
can
create
a
correlation
idea.
Assuming
there
isn't
one
already.
So
we
used
as
your
queues,
which
give
you
a
unique
identifier
for
each
queue
for
each
job,
on
the
queue
out
of
it
off
the
bat.