Python Release Notes

Python Agent Release Notes

Tuesday, June 12, 2012 - 02:30


This release of the Python agent has focused on improving the way the agent communicates with the New Relic core application. This includes improved logging and error handling, but also adds support for SSL and connecting via a proxy when the monitored host is located behind a firewall.

For a list of known issues with the Python agent see our online help article on the status of the Python agent.

Changed features:

  • The request method for a call to an external web service, when able to be collected by instrumentation, is now shown against a web external node in a slow transaction trace where as previously it showed the path segment of the URL. The URL, minus embedded user/password and query string is instead now shown as a label when hovering over the web external node in the slow transaction trace details.

  • Improved logging and error handling when communicating with the New Relic core application. Many messages previously logged as errors will now be logged as warnings and an error only logged when a recurring problem is detected. This should reduce emails triggered from errors logged via the Python logging module to only those that may actually require action.

  • Significant error messages or warnings will be output to standard output when running the agent test via the 'newrelic-admin validate-config' command. This ensures that it will be easier to detect when the test has failed due to network connectivity or license key issues.

New features:

  • Connecting to the New Relic core application using a secure SSL connection is now supported. This is enabled by setting the 'ssl' setting in the agent configuration file to 'true'.

  • Connecting to the New Relic core application via a proxy is now supported. This is enabled by setting the 'proxy_host' and 'proxy_port' settings in the agent configuration file. If a secure SSL connection is desired, the 'ssl' setting can be set to 'true' at the same time. If the proxy requires a user name and password, the 'proxy_user' and 'proxy_pass' settings can be additionally set.

  • When sending collected data to the New Relic core application it will be compressed when over a certain size to cut down on the amount of data being sent.

  • The Python agent now includes its own self instrumentation and profiling capabilities to allow New Relic to monitor the performance of the agent itself and help debug any performance issues reported by a user which may occur in rare circumstances with certain web applications.

Bug fixes:

  • Where a user name and password were being included as part of a URL for a call to an external web service, eg., 'user:pass@localhost/', that the Python agent was instrumenting, the details were not always being scrubbed properly from details being reported to the New Relic core application.
Wednesday, April 25, 2012 - 09:41

Bug fixes:

  • Fix assertion violations when greenlets were used explicitly in the context of a normal thread based request handler.

  • Installation of package using Python 2.5 was giving warnings when trying to byte code compile installed .py files due to missing import for 'with_statement' from __future__ module in some modules.

  • The newrelic-admin script is now installed correctly when installing the package as an egg under buildout.

  • The newrelic.agent.stop_recording() function was causing errors when using any WSGI hosting mechanism other than Apache/mod_wsgi and wasn't working as intended even under mod_wsgi.

  • Disable CPU sampling when os.times() is not available, such as when using Jython.

  • Derivation of name when instrumenting the __init__() method of a class could fail if the class had a __len__() method which accessed methods/attributes which were only setup during the constructor.

  • Move importing of multiprocessing module to global scope to avoid logging module bug in Python versions up to 2.6.

Tuesday, March 27, 2012 - 05:00

Bug fixes:

  • Added full support for being able to use agent package with buildout. Previously the 'newrelic-admin' script was not installed correctly when buildout was being used to manage package installation.

  • Added support for versions 2.2 and 2.5 of the distributed task queuing system Celery.

  • Added support for older 'redis' client versions which did not separate commands into 'StrictRedis' and 'Redis' client objects.

  • The database table name was not always extracted properly from SQL queries where sub selects were being used, especially when additional bracketing was being used for readability. Usually this was occuring where hand crafted SQL was being generated rather than being automatically generated through an ORM or DAL.

  • Type handler registration in psycopg2 client module would fail due to agent instrumentation wrapper around connection and cursor objects.

  • Javascript header added into response of type 'text/html' when Django being used and end user monitoring enabled, would be placed into wrong location of '' element if 'X-UA-Compatible' meta tag existed. This would cause issues for IE browser clients which meta tag related to.

New features:

  • Server side configuation is now available for the Python agent. This will be of most use for Heroku installations where there is by default no agent configuration file for defining local override settings.

  • Distiguish time spent invoking the WSGI application for a request and the subsequent processing of any iterable returned by the WSGI application. These will show as nodes 'WSGI/Application' and 'WSGI/Response' in performance breakdowns and slow transaction traces. This mainly helps where iterable is a generator which performs work for each yielded item as provides proper context. Time spent in writing back a large reponse to a slow HTTP client will also be more visible.

  • Distinguish separately the time spent in the top level WSGI application callable where the agent WSGI middleware wrapper is being applied. This will be the node which gets listed immediately under 'WSGI/Application' in a slow transaction trace.

  • For Django, record separately time spent in processing certain types of form POSTs. This helps to show where being spent processing a large data upload.

  • Show content length and content type details for a request in slow transaction and error details.

  • Show content length for a response in slow transaction and error details.

Features changed:

  • Longer timeout when doing an agent test using the 'validate-config' command of the 'newrelic-admin' script. The short timeout was previously causing some users with slow DNS or networks to see the test as failing.
Tuesday, January 10, 2012 - 17:32


  • Addressed a performance issue which would cause high CPU load, when parsing SQL queries which had a large number of values for a SQL 'IN' clause.

  • Agent version was not reported in form A.B.C.D in all cases. This was causing UI to warn that Python agent was out of date even when running version newer than the minimum recommended version.

  • When 'feedparser' module is used, now correctly track external web service requests where URI used 'feed' or feed:http' for scheme.

  • Illegal non ASCII characters in a URL could cause the agent to generate Unicode conversion warnings or outright fail a request with an exception where the character sequence could not be decoded to Unicode using the Python system default encoding.

  • The table name for a SQL query was not being correctly derived when the SQL contained a select sub query or table name aliases were being used.

  • Number of nodes captured for a slow transaction trace was not being capped properly resulted in too much data being sent through to core application. This could result in details of slow transaction being rejected by core application, or result in a timeout in UI when attempting to display the slow transaction trace.

  • SQL calls made using 'psycopg2' were failing where optional parameters argument was not supplied to database cursor 'execute()' method and the SQL contained a '%' character such as in a 'LIKE' clause.

  • Was not ignoring exception of type 'bottle.HTTPError' raised within application using Bottle. This is not a true exception but is used to programmatically indicate a non 200 HTTP response so shouldn't have been recorded as an error.

  • The 'django-piston' instrumentation was failing when an error occurred in users handler and it tried to generate an error response. This was because 'django-piston' was assuming that a handler would always be a normal function. It would therefore fail for a decorator/wrapper implemented using a class object as is used by the agent instrumentation.

New features:

  • Added support for capturing explain plans for slow SQL when using MySQL and PostgreSQL.

  • Added preliminary public API for manually instrumenting additional functions in user code and interacting with the current transaction to override how and what details about the transaction are recorded.

  • Added the 'transaction_tracer.function_trace' setting in the agent configuration file for providing a simplified way of specifying additional Python functions for which time metrics should be collected. Time spent in these functions will then appear in web transaction performance break down and slow transaction traces.

  • Added new or improved support for tracking external web service requests made using the 'urllib', 'urllib2', 'urllib3', 'httplib', 'httplib2' and 'requests' modules. Note that only time taken for the initial connect for the HTTP connection may be recorded. Uninstrumented time which appears immediately after an external web service request in a slow transaction trace made using one of these modules, will therefore possibly be the time then taken to send request data, wait for a response and consume that response data.

  • Added support for tracking external requests to a Solr service using the 'pysolr' and 'solrpy' modules. Time spent making the request will show on the overview charts as Solr time. Metrics for individual types of requests will also be listed in web transaction performance breakdown and slow transaction traces.

  • Added Django application called 'newrelic.extras.framework_django' which explicitly adds in 'newrelic_tags' tag library containing template tags for manually adding in RUM header and footer. Reliance on the old method whereby template tag library was added automatically is now deprecated and will be removed in a future version.

  • Added support for Bottle 0.10.X in Bottle specific instrumentation.

  • Added support for Redis using the 'redis' module. Support consists of tracking time spent connecting to and issuing commands against the Redis service.

  • Added support for MongoDB using the 'pymongo' module. Support consists of tracking time spent connecting to and issuing commands against the MongoDB service.

Features changed:

  • The 'capture_params' setting was defaulting to 'true' rather than 'false' resulting in the request query string parameters being reported against errors and slow transaction traces. If upgrading you will need to change the agent configuration file you are already using to change it to 'false' if capturing parameters is not desired.

  • Rollup metrics against web transactions for external web service requests will now only be recorded against the host and will not be broken out based on resource requested on the remote service.

Wednesday, November 30, 2011 - 18:10


  • Details of errors were not being captured and passed back to the core application to be displayed by the UI when the URL for the request had query string parameters. The problem was not causing failure of the overall web application but that a problem was occuring would have been identifiable though a Python agent exception and traceback being recorded in the Python agent log file with message:

  • NameError: global name 'request_params' is not defined

  • Slow transactions were never being recorded when agent run using method where no agent configuration file was being used. This is the case for example when using Heroku.

New features:

  • Added support for the distributed task queuing system Celery. Tasks executed by a Celery server can be tracked and reported as background tasks against an application in the New Relic UI.

  • Added support for tracking as external web service requests calls made out via the pywapi module.

  • Added support for automatic wrapping of WSGI application entry point when using flup WSGI adapter for FASTCGI, SCGI and AJP.

  • Added support for meinheld as standalone WSGI server and also as a worker class when using gunicorn.

  • Added support for recording database transactions when using pyodbc.

Tuesday, November 15, 2011 - 18:47


  • Where instrumentation was not available for the web framework or toolkit being used and web transactions were being named according to the original URL, metric normalization rules were not being correctly applied when metric grouping issues occurred due to a large number of unique URLs. This was resulting in grouping of web transactions metrics under incorrect names leading to the data presented by the UI being unhelpful or misleading.

  • Agent would fail when collecting WSGI hosting environment information when an older version of Tornado web server was used which did not provide version information. This would lead to no web transactions metrics being reported as failure occured when agent was trying to register with the New Relic core application.

  • Instrumentation of the feedparser module was not catering for the fact that the parse() function could be supplied arguments beyond just the URL to be retreived. This would result in an exception and the web transaction always failing when such additional arguments were supplied.

  • Instrumentation for Django was improved so that view handler function name was reported against a web transaction rather than URL when using Django static files mechanism.

  • Instrumentation for Django was improved so that technical 404 and 500 response handler function name was used for web transaction when appropriate.

  • Instrumentation for Django was improved to ensure that request middleware function name was always used for web transaction name when it returned a valid response.

Features changed:

  • Attributes captured from WSGI request environment such as 'REQUEST_METHOD', 'HTTP_REFERER' and 'HTTP_USER_AGENT' are now shown under the 'Request environment' category in error details and slow transaction traces rather than under 'Custom parameters'.

  • The HTTP response status for a web transaction is now shown as 'STATUS' under the 'Response properties' category in error details and slow transaction traces rather than under 'Custom parameters'.

Monday, November 14, 2011 - 18:54


The first general release of the Python agent. If you are using an older BETA version of the Python agent you should upgrade as soon as possible as many outstanding issues were fixed leading up to this release. No change history for older versions will be made available.