Djangocon11: Monkeying around at New Relic

Monkeying Around
At New Relic
Graham Dumpleton
DjangoCon September 2011

Web interface (1)

THROUGHPUT

Web interface (1)

RESPONSE TIME

Web interface (1)

BREAKDOWN

Web interface (1)

EXCEPTIONS

Web interface (1)

SLOW TRANSACTIONS

Web transactions

✴When they occurred.
✴How long they ran for.
✴What handled the request.
✴What work was done.
✴Were there any errors.

What work was done?

✴Functions called.
✴Databases operations.
✴External service requests.
✴Memcache operations.

Trace class (1)

import time

class Trace(object):
def __init__(self):
self.start = 0
def enter(self):
self.start = time.time()
def exit(self):
self.duration = time.time() - self.start
print self.duration

Timing code block

def function():
time.sleep(0.1)

trace = Trace()

trace.enter()
for i in range(10):
function()
trace.exit()

Stop on exceptions

def function():
time.sleep(0.1)
raise MissingThisTalk('@pydanny')

trace = Trace()

trace.enter()
try:
for i in range(10):
function()
finally:
trace.exit()

Catch exception (1)

def function():
time.sleep(0.1)
raise NotVeryHappy('@pydanny')

trace = Trace()

trace.enter()
try:
for i in range(10):
function()
except:
print sys.exc_info()
raise
finally:
trace.exit()

Trace class (2)

import time

def __init__(self):
self.start = 0
def enter(self):
def exit(self,
exc=None, value=None, tb=None):
print exc, value, tb
print self.duration

Catch exception (2)

trace = Trace()

success = True
trace.enter()
try:
function()
except:
success = False
trace.exit(*sys.exc_info())
raise
finally:
if success:
trace.exit(None, None, None)

Hang on!

✴Doesn’t this pattern look familiar.

Hang on!

✴Doesn’t this pattern look familiar.
✴Isn’t this just a context manager?

Context managers

trace = Trace()

with trace:
function()

Trace class (3)

import time

def __init__(self):
self.start = 0
def __enter__(self):
def __exit__(self,
exc=None, value=None, tb=None):
print exc, value, tb
print self.duration

Catch exception (3)

trace = Trace()

success = True
trace.__enter__()
try:
function()
except:
success = False
if not trace.__exit__(*sys.exc_info()):
raise
finally:
if success:
trace.__exit__(None, None, None)

Decorating functions (1)

def decorator(f):
def wrapper(*args, **kwargs):
with Trace():
return f(*args, **kwargs)
return wrapper

@decorator
def function():
time.sleep(1.0)

function()

Decorator issues (1)

def decorator(f):
with Trace():
return wrapper

@decorator
@csrf_exempt
def handler():
...


def decorator(f):
with Trace():
return wrapper

@decorator
@csrf_exempt
def handler():
...

Why is my view expecting CSRF token?


import functools

def decorator(f):
@functools.wraps(f)
with Trace():
return wrapper

@decorator
def function():
time.sleep(1.0)

function()


class Object(object):
@decorator
@staticmethod
def function():
time.sleep(1.0)

o = Object()

o.function()


class Object(object):
@decorator
@staticmethod
def function():
time.sleep(1.0)

o = Object()

o.function()

AttributeError: 'staticmethod' object
has no attribute '__module__'

Descriptor issues

def available_attrs(f):
# http://bugs.python.org/issue3445.
return tuple(a for a in
functools.WRAPPER_ASSIGNMENTS
if hasattr(f, a))

def decorator(f):
@functools.wraps(f, available_attrs(f))
with Trace():
return wrapper

Descriptor issues

def available_attrs(f):
# http://bugs.python.org/issue3445.
return tuple(a for a in
functools.WRAPPER_ASSIGNMENTS
if hasattr(f, a))

def decorator(f):
@functools.wraps(f, available_attrs(f))
with Trace():
return wrapper

TypeError: 'staticmethod' object is
not callable


class Wrapper(object):
def __init__(self, func):
functools.update_wrapper(self, func,
available_attrs(func))
self.func = func

def __get__(self, instance, klass):
if instance is None: return self
desc = self.func.__get__(instance, klass)
return self.__class__(desc)

def __call__(self, *args, **kwargs):
with Trace():
return self.func(*args, **kwargs)

def decorator(func):
return Wrapper(func)

WSGI application (1)

@decorator
def application(environ, start_response):
status = '200 OK'
start_response(status,
[('Content-type', 'text/plain'),])

time.sleep(1.0)
return ['Is @pydanny here yet?']

WSGI application (2)

@decorator
status = '200 OK'
start_response(status,
[('Content-type', 'text/plain'),])

time.sleep(1.0)
yield 'Maybe @audreyr is watching.'

WSGI middleware (1)

class Wrapper(object):

...

def __call__(self, environ, start_response):
trace = Trace()
trace.__enter__()

try:
result = self.f(environ, start_response)
except:
trace.__exit__(*sys.exc_info())
raise

return Iterable(trace, result)

WSGI middleware (2)

class Iterable(object):

def __init__(self, trace, generator):
self.trace = trace
self.generator = generator

def __iter__(self):
for item in self.generator:
yield item

...

WSGI middleware (3)

class Iterable(object):

...

def close(self):
try:
if hasattr(self.generator, 'close'):
self.generator.close()
except:
self.trace.__exit__(*sys.exc_info())
raise
else:
self.trace.__exit__(None, None, None)

Agent initialisation (1)

import newrelic.agent
newrelic.agent.initialize('/etc/newrelic.ini')

@newrelic.agent.wsgi_application()
...

Agent initialisation (2)

import newrelic.agent
newrelic.agent.initialize('/etc/newrelic.ini')

import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()

PEP 369 / Post import hooks

@imp.when_imported('django.core.handlers.wsgi')
def instrument(module):
method = module.WSGIHandler.__call__
module.WSGIHandler.__call__ =
WSGIApplicationWrapper(method)

DIY post import hooks (1)

class ImportHookFinder:
def __init__(self):
self._skip = {}

def find_module(self, fullname, path=None):
if not fullname in _import_hooks: return None
if fullname in self._skip: return None
self._skip[fullname] = True
try:
__import__(fullname)
finally:
del self._skip[fullname]
return ImportHookLoader()

DIY post import hooks (2)

class ImportHookLoader:

def load_module(self, fullname):
module = sys.modules[fullname]
_notify_import_hooks(fullname, module)
return module

sys.meta_path.insert(0, ImportHookFinder())

Instrumentation

from newrelic.api.web_transaction
import wrap_wsgi_application

wrap_wsgi_application(module,
'WSGIHandler.__call__')

WSGI applications (1)

✴Context manager
✴Trace -> WebTransaction


✴Context manager
✴Trace -> WebTransaction
✴Wrapper/Descriptor
✴Wrapper -> WSGIApplicationWrapper


✴Decorator
✴decorator -> wsgi_application()


✴Decorator
✴decorator -> wsgi_application()
✴Monkey patching
✴wrap_wsgi_application()

Function trace (1)

✴Context manager
✴Trace -> FunctionTrace

Function trace (1)

✴Context manager
✴Trace -> FunctionTrace
✴Wrapper/Descriptor
✴Wrapper -> FunctionTraceWrapper

Function Trace (2)

✴Decorator
✴decorator -> function_trace()

Function Trace (2)

✴Decorator
✴decorator -> function_trace()
✴Monkey patching
✴wrap_function_trace()

Same again

✴DatabaseTrace, etc
✴ExternalTrace, etc
✴MemcacheTrace, etc

Database Trace (1)

from newrelic.api.database_trace
import wrap_database_trace

def _sql(cursor, sql, params=()):
return sql

wrap_database_trace(module,
'Cursor.execute',
sql=_sql)

Database Trace (2)

class DatabaseTraceWrapper(object):

def __init__(self, func, sql):
functools.update_wrapper(self, func,
available_attrs(func))

if type(func) == tuples.TupleType:
self.instance, func = func
else:
self.instance = None

self.func = func
self.sql = sql

Database Trace (3)


def __get__(self, instance, klass):
if instance is None: return self
desc = self.func.__get__(instance, klass)
return self.__class__((instance, desc))

Database Trace (4)


if not isinstance(self.sql, basestring):
if (self.instance and
inspect.ismethod(self.func)):
sql = self.sql(self.instance,
*args, **kwargs)
else:
sql = self.sql(*args, **kargs)
else:
sql = self.sql

with DatabaseTrace(sql):
return self.func(*args, **kwargs)

But it fails!!!

✴Not all Python DBAPI modules are Python

But it fails!!!

✴Not all Python DBAPI modules are Python
✴Can’t wrap methods of Python C objects

Cursor wrapper (1)

module.connect = ConnectionFactory(
module.connect)

Cursor wrapper (2)

class ConnectionWrapper(object):
def __init__(self, connection):
self.__connection = connection
def __getattr__(self, name):
return getattr(self.__connection, name)
def cursor(self, *args, **kwargs):
return CursorWrapper(
self.__connection.cursor(
*args, **kwargs))

class ConnectionFactory(object):
def __init__(self, connect):
self.__connect = connect
return ConnectionWrapper(
self.__connect(*args, **kwargs))

Cursor wrapper (3)

def _sql(sql, params=()):
return sql

class CursorWrapper(object):
def __init__(self, cursor):
self.__cursor = cursor

def execute(self, *args, **kwargs):
return DatabaseTraceWrapper(
self.__cursor.execute,
_sql)(*args, **kwargs)

def __getattr__(self, name):
return getattr(self.__cursor, name)

Enough already

✴Too much information to cover.
✴Is never enough time for it all.

Enough already

✴So so come and talk to us later.

Enough already

✴Get a demonstration of New Relic.

Enough already

✴Get a demonstration of New Relic.
✴Drinks and nibbles Wednesday evening.

Questions?

http://newrelic.com/djangocon
python-beta@newrelic.com

Graham Dumpleton
graham@newrelic.com

Graham.Dumpleton@gmail.com
@GrahamDumpleton

Djangocon11: Monkeying around at New Relic

More Related Content

What's hot (20)

Viewers also liked (9)

Similar to Djangocon11: Monkeying around at New Relic (20)

More from New Relic (20)

Recently uploaded (20)

Djangocon11: Monkeying around at New Relic

Editor's Notes