►
From YouTube: ActiveSupport::Notifications instrumentation
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
B
Cool,
do
I
sound
all
right
through
the
airpods
or
is
it
does
it
sound
as
crap
as
they
usually
do
right,
yeah.
B
I
can
well
if
no
one
else
is
still
here:
I
can
turn
them
off.
Actually
I'll
I'll,
ditch
him
and
swap
back
to
the
building
ones.
Okay,.
B
That's
coming
out
all
right.
That's
all
right!
Sorry,
but
the
work
laptop
doesn't
support
my
like
proper
camera
and
microphone
set
up,
so
I
just
had
to
use
the
built-in
stuff,
which
is
kind
of
annoying
right
I'm,
going
to
share
my
screen.
B
Can
everyone
see
this
okay,
or
is
this
like
weirdly
tall,
otherwise
is
killed?
Okay.
So
this
was
an
issue
from
last,
oh
God.
How
many
releases
ago
was
that
it
was
a
few
releases
ago,
but
this
one
was
kind
of
interesting
in
that
it
was
actually
a.
B
It
was
a
customer
request
and
I'm
just
gonna
move
over
to
the
other
screen.
Actually
yeah,
probably
the
easiest
and
I
can
look
at
right.
Okay,
now
it
doesn't
look
like
I'm
just
looking
off
into
the
middle
of
nowhere
yeah.
So
there's
a
customer
request
and
I
don't
think
it
mentions
which
customer
this
is
in
the
issue
it
doesn't,
which
is
good,
because
this
is
being
recorded
So.
They
were
having
an
issue
where
anytime,
they
were
doing
git
clones.
B
B
But
then
I
found
out
that
we
actually
don't
have
any
logs
or
metrics
at
all
in
any
form
to
say
how
long
we're
spending
in
it
or
that
requests-
and
it
just
so
happened
that
this
is
only
if
you
clone
over
https
and
not
over
git
like
SSH,
because
if
you
do
SSH,
you
use
SSH
keys
to
perform
the
Clone
to
perform
the
authentication.
But
if
you
do
https,
it
requires
you
to
sign
in
with
your
account
and
their
accounts
are
ldap
accounts.
B
So
that
was
my
theory,
but
in
order
to
prove
it,
I
actually
had
to
go
and
add
ldap
logging
effectively
to
the
application,
and
thankfully
it
actually
does
turn
out
ovals
right.
It
was
ldap,
the
login
worked
and
it's
been
proven.
That
is
actually
their
problem.
So
it's
pretty
cool
but
to
actually
add
it
was
kind
of
fun
because
I
had
to
use
something.
I
have
actually
never
used
in
rails
before,
which
is
this
active
support?
Notifications
thing:
has
anyone
actually
used
this
before?
Does
anyone
come
across?
B
This
really
has
yeah
it's
I
I,
never
even
heard
of
this
before
I.
Don't
know
how
completely
missed
it,
but
it's
an
instrumentation
API
for
Ruby.
They
say
for
Ruby,
but
I
mean
it
is
our
rails
and
I.
Think
most
of
rails
is
instrumented
with
this
by
default
turns
out
that
we
actually
do
some
stuff
ourselves
as
well,
and
then
you
sort
of
hook
into
it.
Thankfully,
the
actual
the
net
ldap
Library
supports
it.
B
So
these
are
the
adapter
options
for
the
ldap
the
world
for
r
l,
dap
I
should
have
just
loaded
this
up
hell
that
wrapper,
but
he
uses
the
the
net
held
app
class
somewhere.
B
B
Effectively
you're
using
this,
this
net
ldap
Library,
wherever
the
call
is
for
it,
and
there
are
some
base
options
that
are
set
up
for
that,
and
then
this
library
is
called
so
next
ldap
I'll,
actually
open
up
here
has
support,
as
it
turns
out
in
its
config
options.
B
B
So
really
all
I
needed
to
do
was
to
add
in
support
for
that,
and
then
it
starts
delivering
this
data
so
the
measurements
it
uses
it
to
measure
how
long
things
take
and
it's
then
just
available
somewhere,
and
there
wasn't
really
any
explanation
as
to
where
you
then
do
the
other
bit
where
you
actually
subscribed
to
it
and
where
you
get
that
data,
are
you
added
to
the
logs
and
I
eventually
did
figure
it
out,
but
it
took
quite
a
lot
of
trial
and
error
and
it
turns
out
we
have
a
hierarchy
here
of
git
love,
metrics
subscribers
and
there's
a
few
of
these
in
that
folder.
B
There
are
a
bunch
of
let's
see
if
I
can
find.
B
So
there's
a
bunch
of
these
to
add
support
for
some
other
parts
of
it.
So,
like
view,
timings
and
stuff
like
that,
and
it
hooks
in
and
follows
those
active
support,
notification
events
and
then
you
can
do
what
you
want
with
them.
So
it
turns
out
that
this
folder
is
effectively
used
for
two
different
things.
It
is
used
for
metrics,
but
it's
also
loaded
into
the
logger.
B
And
now
that
seems
a
little
bit
weird
to
me.
I
would
have
thought
they'd
have
been
separate,
but
I
guess
it
kind
of
makes
sense,
so
this
class
does
both
it
adds
it
you
do
have
to
for
every
event.
You
want
to
listen
to
the
API,
for
this
is
really
weird
on
your
subscriber
for
each
event,
you
want
to
listen
to.
You
have
to
have
a
public
method
named
the
same
as
that
event.
Name,
that's
a
bit
weird
I!
B
Don't
really
get
that
so
I
botched
it
and
only
a
step
for
all
of
the
events,
because
I'm
not
running
out
the
same
method
10
times
I
just
feels
really
pointless
to
me.
Oh
sorry,
is
there
a
chat
message?
B
B
It
calls
observe
events
because
it's
Alias
to
things
so
when
there's
an
event
of
open,
this
class
gets
called
with
a
method
of
open
with
the
event
payload,
so
it
logs
some
of
the
data
in
the
request.
So
if
there
are
multiple
ones
in
the
request,
the
times
will
add
up,
and
then
it
exposes
the
metrics
for
Prometheus,
which
then
ends
up
no
way.
That's
wrong.
B
Isn't
it
Prometheus
ends
up
in
Prometheus,
grafana
and
the
logs
end
up
in
kibada,
but
they're
the
same
bits
of
data
I
just
added
to
them
to
both,
and
that
was
a
little
it's
a
little
bit
weird
doing
them
into
both,
but
it
kind
of
makes
sense.
So
most
of
the
rest
of
it
is
just
about
getting
this
data.
We
only
really
care
about
two
things:
the
number
of
ldap
requests
which
counter
and
the
duration
of
the
ldap
request.
So
the
exposed
metrics
method
is
where
these
are
added
to
the
Prometheus
exporter.
B
So
this
is
incrementing
at
the
counter
and
it's
doing
an
observing
thingy
for
the
times.
I
won't
go
into
how
Prometheus
works.
It's
weird
like
it's
really
weird
I'm
happy
to
go
through
it
in
the
future,
but
it's
just
weird,
but
the
logging
is
is
old
again,
because
this
is
the
method
that's
used
for
logging,
so
none
of
the
logging
happens
in
this
file.
Instead,
we
have
something
called
the
instrumentation
helper,
which
merges
the
fields
into
the
logs.
B
This
is
a
bit
of
a
I'll
move.
The
videos
over
that
way
that
so
the
instrumentation
helper
does
a
lot
of
things.
As
you
can
see,
it
does
implementation
of
Gita
leaders
rugged
redis,
elastic
search.
All
of
these
so
I
just
added
a
new
method
and
each
one
fetches
this
data
from
different
places,
but
a
lot
of
them
do
come
from
these
metric
subscribers.
B
So
rack
attacks
there,
for
example,
but
then
others
come
from
other
places
like
gear
lab,
instrumentation
classes,
so
I
just
added
on
to
the
end
of
it
a
new
ldap
one
and
it
cools
the
count
from
that
and
checks
that
there
is
actually
an
all
that
request
before
it
adds
it
to
the
logs,
because
I
did
have
some
feedback
that
people
didn't
want
to
increase
the
log
size
on
your
lab.com
any
further.
B
B
To
the
logs,
the
I
think
that
these
originally
find
where
the
I
think
this
gets
loaded
in.
B
B
B
All
right
here
we
go
yeah,
so
this
is
where
all
of
those
things
get
added
to
the
payload
for
each
log
message.
So
this
is
like
the
start
of
the
point
for
the
logs,
so
that
caused
the
instrumentation
helper,
which
caused
all
the
metrics
dinghies
that
adds
all
the
data
to
the
logs
and
that's
where
it
eventually
gets
it
from.
B
But
the
data
is
sort
of
collected
in
the
background
where
this
event,
emitter
from
active
support
notifications,
so
you've
got
the
active
score
notifications
and
then
you
can
create
these
sort
of
subscribers
and
all
this
sort
of
stuff.
The
one
thing
that
was
really
weird
I
think
I
added
some
I've
added
more
documentation
to
this
than
most
of
the
other
subscribers.
B
So,
like
the
name
yeah
like
the
names,
so
net
held
app.
Logically,
that
should
be
at
the
start
of
the
key
like
the
event
name,
that's
how
I've
always
thought
of
a
namespace.
You
have
the
namespace
first,
then
you
have
like
the
specific
event
afterwards,
but
it's
back
to
front
and
I.
Don't
really
understand
why
I
said
it'll
be
weird
to
me
and
that's
not
documented
anyway.
That
was
just
trial
and
error
until
I
eventually
found
out
exactly
how
that
works.
B
So
there's
a
few
weird
things
like
that
and
I
think
I'll
documented
all
of
them
in
here,
but
yeah
I,
hopefully
covered
exactly
what's
needed
in
that,
but
I
think
that's
it.
That
is
ultimately,
is
quite
simple,
but
it
did
take
about
a
week
to
figure
out
how
to
actually
do
it.
B
A
Yeah
great
great
great
one
to
show
Robert
because,
as
you
said
like
we
don't
normally
get
in
there
and
you're
you're
deep
in
the
depths
of
kid
lab,
and
that's
quite
interesting,
you
asked
had
anyone
come
across
the
actors?
Support
notifications,
I've
never
actually
worked
with
it,
but
I
I've
looked
inside
a
few
gems,
those
those
kind
of
like.
A
Like
a
robot,
those
that
they
use
it,
but
yeah
super
interesting
and
I
do
have.
One
question,
though,
is
how
did
you
test
all
of
this.
B
So
I
had
to
configure
ldap
locally,
which
you
can
do
and
it's
not
too
awful.
You
I
think
you
just
basically
change
your
your
gitlab
config
via
the
GDK
and
say
enable
ldap
or
whatever.
Then
you
have
to
reconfigure
it.
Then
it
sort
of
just
works.
B
They've
got
ldap
users
installed
by
default,
but
then
I
had
a
load
of
problems
where
I
couldn't
actually
see
these
log
messages,
and
so
I
thought
I
was
going
insane
and
I'd
not
written
it
correctly,
but
as
it
turns
out,
the
ldap
requests
don't
happen
all
the
time.
There's
quite
a
lot
of
caching
that
goes
on
in
it,
and
yeah.
B
Eventually,
I
figured
out
that
if
you
killed
all
the
sessions
and
started
up
again,
you'd
start
seeing
the
long
messages,
but
they
are
intermittent
like
it
doesn't
always
re-authenticate
but
yeah
as
I
tested
it
locally
using
that
and
then
just
hoped
that
it
was
actually
the
solution,
because
I
had
no
evidence
at
all
that
it
was
actually
the
problem,
but
it
was
which
is
nice.
So.
C
Yeah
actually
I
have
a
comment
rather
than
a
question
yeah.
Just
this
problem,
yeah
looks
really
interesting,
yeah
I
hope
so
and
but
at
the
same
time
it
is
not
related
to
source
code
at
all
and
I'm
I'm.
Not
how
often
it
happens
that
some
particular
problem,
for
example,
starts
with
Git
push
or
something
like
this,
because
it's
a
very
popular
entry
point
and
all
those
issues
goes
to
our
team
go
to
our
team.
But
then
it
turns
out
that
it's
not
related
to
source
code
at
all,
so
yeah.
B
Definitely
one
of
those
like
this
one
counted
as
ours
because
it
involved
a
git
push,
but
that
if
I
could
prove
that
it
was
not
if
I
could
prove
it
was
ldat
and
they
didn't
and
they
need
further
help.
I
can
shove
it
on
to
authentication,
because
that's
technically
theirs,
but
yeah
we've
always
been
the
team
that
gets
all
of
the
bits
that
nobody
else
knows
if
it's
theirs
or
not
like.
B
B
We
always
end
up
with
the
weird
things.
I
think.
A
It's
a
great
it's
a
great
point
and
I
think
you
definitely
took
the
right
approach
on
this.
One
Robert
and
I
think
had
it.
You
know
that
this
could
be
then,
as
you're
saying.
A
This
could
be
then
handed
off
to
authentication
if
it
needed
more
work,
but
yeah
I,
guess
I,
guess
part
of
the
reason
is
maybe
we're
just
a
great
team,
but
but
probably
possibly
yeah
like
the
fact
that
we're
the
we're
the
entry
point
right
like
get
push
or-
or
you
know
in
this
case
https
but
yep.
B
Yeah
I
think
when
it
came
to
this
one,
the
as
I
was
on
a
customer
call
with
them.
They
couldn't
actually
reproduce
it
on
the
development
server,
which
was
weird,
but
it
was
just
like
an
offhand
comment
they
made
when
they
were
on.
The
call
that
made
me
suspect
that,
prior
to
that,
we
had
no
information
that
they
were
even
using
ldap
yeah.
B
It
was
a
little
bit
weird,
but
because
it's
out
there
like
as
a
as
a
sort
of
a
how
it
works
and
the
difficulty
is
that
it
would,
if
it
had
gone
to
deal
with
the
authentication
group,
it
would
probably
have
just
been
able
to
help
them
solve
the
problem,
but
I
essentially
put
in
an
awful
lot
more
work
just
so
that
we
don't
have
to
do
future
work
so
like
it's
by
doing
more
work
to
do
slightly
less
work
in
the
future.
Maybe
because
now
people
can
solve
this
for
themselves
in
theory.
B
But
if
this
hadn't
been
the
solution,
I
had
literally
no
other
ideas.
I
I
had
nothing
planned
sector
to
come
up
after
this,
so
I'm
really
glad
there
was
a
there.
Was
this
yeah.
A
Head
off
to
you,
Robert
and
in
fact,
and
also
you
know,
prepared
to
put
something
in
chat
about
the
investment,
because
there's
also
an
investment
in
your
own
knowledge.
Road
like
you've,
you've
got
you
got
to
learn
how
all
this
stuff
works
internally,
which
is
a
bit
obscure
right,
yeah,.
B
Done
stuff
in
the
past
around
the
Prometheus
exporters,
so
people
like
an
explanation
of
how
that
works
in
the
future
I'm
happy
to
do
that.
I
actually
run
my
own
Prometheus
exporters
at
home
as
well
and
I've
written
my
own
from
scratch.
So
that
can
be
quite
interesting,
but
the
the
weird
thing
here
was
sort
of
figuring
out
how
we're
already
setting
it
up,
because
this
isn't
entirely
normal,
like
the
using
the
same
class
of
both
logs
and
metrics,
is
a
little
bit
bizarre.
But
it
does
kind
of
make
sense.
A
That's
that's
great.
It's
really
great,
so
yeah
we're
in
almost
perfectly
on
time.
Thank
you
very
much
Robert.
That
was
actually
awesome.
I'm
going
to
stop
the
recording.