Python agent release notes

Python agent v10.0.0

Thu, 26 Sep 2024 00:00:00 +0000

Notes

This release of the Python agent drops support for Python 2.7 and adds the following:

a Kafka server metric
host and port attributes for memcache
support for kafka-python-ng
support for uvicorn_worker
an environment variable for garbage collector (GC) runtime metrics
automatic detection for the function signature in LangChain's similarity_search
updated support for OpenAI's chat class
a fix for a bug in gRPC's entity name detection
a fix for transaction context propagation loss in LangChain in the case of a new thread
parsing of the request and response when running OpenAI via LangChain
a fix for pyscopg v3 API incompatibilities
a fix that removes versioned logic in loguru instrumentation

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Deprecations

Remove Python 2.7 Support
- Removes compatibility with Python 2.7. Also removes support for the following libraries that were only supported on Python 2.7:
  - umemcache
  - oursql
  - pywapi
  - Pylons
  - web2py
  - weberror

New features

Add Kafka server metric
- Adds a metric to capture the host and port information for Kafka entities on both consumers and producers. This metric allows the UI to link AWS information with AWS MSK entities in the service map.
Add capturing of memcache host and port
- Adds capturing of host and port info on the following memcache libraries: bmemcached, aiomcache, and pymemcache. This allows the UI to link AWS information with AWS memcache entities in the service map.
Add support for kafka-python-ng
- kafka-python has been released under a new name: kafka-python-ng. This continues to support kafka-python under the new package name.
Add support for uvicorn_worker
- uvicorn.workers has been moved to a separate package called uvicorn_worker. This checks for both names of the module when reporting dispatcher information.
Automatically detect function signature in LangChain similarity_search
- Automatically detect the function signature when wrapping similarity_search.
Add environment variable for garbage collector runtime metrics
- Garbage collector runtime metrics can now be enabled/disabled via the following environment variable: NEW_RELIC_GC_RUNTIME_METRICS_ENABLED.

Bug fixes

Fix bug in gRPC entity name detection
- Previously, the gRPC channel entity name was missing the first character(s) in specific cases. This bug has been fixed.
Fix issue in LangChain where a thread is started and the transaction context is lost
- Previously, when LangChain called certain chains, such as retrieval chains, LangChain started a thread that caused the transaction to be lost, resulting in broken instrumentation. This has been fixed so the transaction context is passed across threads and instrumentation still works for retrieval chains.
Fix parsing of request and response when running OpenAI via LangChain
- Previously, when running OpenAI via LangChain the request and response were a different format and were not being recorded. This issue has been fixed.
Instrument new path to OpenAI chat completions class
- OpenAI moved the ChatCompletions class to a different path which prevented the instrumentation from being applied. This has been fixed.
Fix pyscopg v3 API incompatibilities
- Expand DBAPI2 wrappers to allow arbitrary kwargs on executemany(). Upgrade psycopg v3 instrumentation to allow arbitrary kwargs on executemany(). Rename existing psycopg v3 wrapper arguments to match the upstream library's names for compatibility.
Remove versioned logic in loguru instrumentation
- Removed versioned logic in loguru instrumentation to fix a bug that occurred when the version was undeterminable.

Support statement

We recommend updating to the latest agent version as soon as it's available. If you can't upgrade to the latest version, update your agents to a version no more than 90 days old. Read more about keeping agents up to date.

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.1.0

Thu, 10 Oct 2024 00:00:00 +0000

Notes

This release of the Python agent adds support for Python 3.13, adds a new Large Language Model (LLM) API, supports Docker ID parsing in Amazon ECS Fargate environments, and instruments a new Langchain vectorstore.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for Python 3.13
- The agent now supports applications running in Python 3.13.
Add new LLM custom attribute context manager API
- The agent now includes a new context manager API that adds custom attributes to LLM events generated from calls to LLMs in application code. For more information on usage, please see our API documentation.
Add support for reporting of Amazon ECS Fargate Docker IDs
- The agent now reports Docker IDs for containers running in ECS Fargate environments.
Add instrumentation for SQLiteVec vectorstore in Langchain
- The agent now instruments similarity_search for the SQLiteVec vectorstore.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.3.0

Mon, 18 Nov 2024 00:00:00 +0000

Notes

This release of the Python agent adds support for Valkey, configuration via TOML file, protobuf v5 for infinite tracing, attaching custom attributes and labels to log events, and some minor cleanup of HTTPX instrumentation. HTTP/2 support was validated for Daphne, Hypercorn, and HTTPX. Module information is now collected periodically which fixes a bug where the CPU usage would spike on application startup.

The Python agent now allows you to opt-in to adding your custom tags (labels) to agent-forwarded logs. With custom tags on logs, platform engineers can easily filter, search, and correlate log data for faster and more efficient troubleshooting, improved performance, and optimized resource utilization. To learn more about this feature see the documentation.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for Valkey
- Add instrumentation for Valkey. Thanks @jairhenrique for the contribution!
Add TOML configuration file support
- Support to read TOML configuration is now available. Thanks @Tatsh for the contribution!
Add infinite tracing pb2 file for protobuf v5
- This adds an additional pb2 file used for infinite tracing that is compatible with protobuf v5.
Add support for attaching custom attributes to logs
- A new configuration option has been added called application_logging.forwarding.custom_attributes that will add custom attributes to all log events when set.
Add support for attaching labels to log events
- Labels as attributes can now be added to log events. When application_logging.forwarding.labels.enabled is set the values in labels will be added to all log events. Labels can be excluded by setting application_logging.forwarding.labels.exclude.

Enhancements

Minor cleanup of HTTPX instrumentation
- Some minor cleanup was done in the HTTPX instrumentation.
Validate HTTP/2 support
- Added tests to ensure HTTP/2 support for the following frameworks:
  - Daphne
  - Hypercorn
  - HTTPX

Bug fixes

Collect module information from application periodically instead of at startup
- Previously, the New Relic Python agent collected the application's module information all at once during startup. In some extreme cases this would cause a large spike in CPU usage. This enhancement allows the agent to do this incrementally throughout the application's operation, preventing potential memory spikes during agent startup.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.3.1

Mon, 25 Nov 2024 00:00:00 +0000

Notes

This release of the Python agent fixes a bug in the package version collector that disabled telemetry from being sent to New Relic in certain cases.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Bug fixes

Fix agent crash when uploading package version info
- Previously, if package versioning was a class property then the function itself was sent with the payload. This would then display the __repr__() of the versioning class in the environment stats. In v10.3.0, this task was tweaked and moved to the harvest cycle that caused a failure during the payload conversion to JSON and disabled the telemetry transmission. This release introduces logic to exclude invalid data types from the module payload.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.2.0

Tue, 15 Oct 2024 00:00:00 +0000

Notes

This release of the Python agent adds a flag for the Azure init container operator.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add Azure Init Container Operator Flag
- New Relic can be integrated into applications hosted on Microsoft Azure, either directly, through an init container for Azure Container Apps, or a pre-build startup script for Microsoft Azure App Service. You can flag that this is the installation method used by setting the NEW_RELIC_AZURE_OPERATOR_ENABLED environment variable.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.4.0

Thu, 12 Dec 2024 00:00:00 +0000

Notes

This release of the Python agent adds support for async PyMongo, Motor, aiomysql, a new AWS account ID configuration setting, linking AWS entities for DynamoDB and Lambda, and fixes a path typing issue in newrelic.initialize().

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for async PyMongo
- Instrumentation support was added for asynchronous PyMongo. Note that this API is currently in beta and may be subject to future breaking changes, which may affect instrumentation.
Add support for Motor
- Instrumentation support was added for motor.
Add support for aiomysql
- Add support for aiomysql.
Add new AWS account ID configuration setting
- Some AWS instrumentations are not able to automatically determine the AWS account ID which is used to link the AWS entity in the service map. When cloud.aws.account_id is set, it will be used in certain AWS instrumentations such as DynamoDB to link the DynamoDB AWS entity in the service map.
Link AWS entity for DynamoDB
- Add linking to the AWS entity in the service map for DynamoDB. This linking is done by utilizing the cloud.aws.account_id configuration setting.
Link AWS entity for Lambda
- Add linking to the AWS entity in the service map for Lambda. This linking is done by attaching the ARN to the lambda call's span.

Bug fixes

Fix path typing issue in newrelic.initialize()
- Fixes a bug in newrelic.initialize() where pathlike objects were not accepted. This has been corrected to support strings, bytes, or PathLike objects.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.5.0

Wed, 29 Jan 2025 00:00:00 +0000

Notes

This release of the Python agent adds Agent Control health reporting, instrumentation for cassandra-driver, support for new a langchain vectorstore, improves NewRelicContextFormatter stack traces logging, fixes compatibility issues with the structlog ProcessorFormatter, and checks for ExceptionMiddleware removal in starlette.exceptions.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add Agent Control health reporting
- Adds agent health reporting capability to support the upcoming release of New Relic Fleet Control.
Add support for cassandra-driver
- Instrumentation support was added for cassandra-driver.
Add support for new langchain vectorstore
- Adds instrumentation for TablestoreVectorStore in langchain.
Enhance stack traces logged by NewRelicContextFormatter
- The NewRelicContextFormatter now reports exception causes when logging stack traces. Thanks @sweco for your contribution!

Bug fixes

Fix compatibility issues with structlog's ProcessorFormatter
- Fix was added for the case where the structlog ProcessorFormatter is used as a logging.Formatter for both logging and structlog log entries.
Check for ExceptionMiddleware removal in starlette.exceptions
- After starlette v0.45.0 the import proxy for ExceptionMiddleware was removed from starlette.exceptions (and now only resides in starlette.middleware.exceptions).

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.9.0

Fri, 11 Apr 2025 00:00:00 +0000

Notes

This release of the Python agent adds OpenTelemetry compatible datastore span attribute names, fixes a bug in LangChain instrumentation, and temporarily disables Kombu instrumentation.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add OpenTelemetry compatible datastore span attributes
- The datastore span attributes are now more consistent with OpenTelemetry naming conventions

Bug fixes

Fix LangChain instrumentation for string response types
- Previously, when LangChain returned string-type responses, the agent only captured the first character of the string. This has been corrected.
Disable Kombu instrumentation
- Existing Kombu instrumentation in the agent is crashing with a TypeError being raised from the inspect module. This instrumentation has been temporarily disabled and will be re-enabled in a future release once the root cause of the crash is identified and patched.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.7.0

Thu, 06 Mar 2025 00:00:00 +0000

Notes

This release of the Python agent adds support for asynchronous AWS Bedrock LLM calls in aioboto3, a fix for a segfault with greenlets, a fixed a crash in aiomysql instrumentation, and reformatted the codebase with Ruff.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for asynchronous AWS Bedrock LLM calls
- Adds instrumentation to support calls to invoke_model and invoke_model_with_response_stream made on aioboto3 clients

Bug fixes

Fix crash in aiomysql instrumentation
- Previously, using aiomysql.sa (the included sqlalchemy engine) with the agent would result in a crash due to a missing __await__ method in the instrumentation. This has been corrected.
Fix segfaults with greenlets
- Previously, a segfault occured when the maximum number of worker processes were called. This was due to a combination of using a weak reference for the agent's trace ID caching and greenlet's greenlet.getcurrent() retrieval function being called after the last greenlet has already been garbage collected. This fix allows the worker process to restart without the segfault occurring.

Changes

Reformatted entire codebase with Ruff
- Switched to Ruff linter and reformatted the entire codebase.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.6.0

Thu, 06 Feb 2025 00:00:00 +0000

Notes

This release of the Python agent adds entity linking for AWS Kinesis and AWS Firehose in boto3 and botocore.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add entity linking attributes for AWS Kinesis and AWS Firehose when using boto3 and botocore.
- Adds attributes linking distributed traces with AWS Kinesis and AWS Firehose entities in the New Relic UI.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.8.1

Mon, 31 Mar 2025 00:00:00 +0000

Notes

This release of the Python agent fixes a bug with the latest Kombu instrumentation.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Bug fixes

Fix import error in Kombu instrumentation
- A missing import in Kombu's instrumentation resulted in a crash for those using the instrumentation. This has now been fixed.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.8.0

Thu, 27 Mar 2025 00:00:00 +0000

Notes

This release of the Python agent adds support for Kombu, mysqlclient, PyMySQL, and adds a few safeguards to prevent exceptions.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for Kombu
- Add support for producer and consumer message tracing in Kombu.
- In the case where Celery and Kombu are used together, a transaction is produced for both Celery and Kombu message consumption and Kombu consumer tracing is turned off by default. It can be enabled via the instrumentation.kombu.consumer.enabled setting. A new setting instrumentation.kombu.ignored_exchanges to ignore certain exchanges was also added and by default it ignores the celeryev queue which is a monitoring queue.
Add support for mysqlclient (a MySQLdb fork for Python 3)
- Instrumentation for the Python 2 library MySQLdb has been adapted to support the Python 3 fork mysqlclient.
Update instrumentation for PyMySQL for versions 1.0.3 and above
- Instrumentation for PyMySQL has been updated for newer versions of the library, and versions below 1.0.3 are no longer supported.

Bug fixes

Safeguard startup of agent healthchecks against exceptions
- Previously, the agent healthchecks could raise exceptions during startup, potentially resulting in agent crashes. This has been fixed.
Fix warning message around garbage collection runtime metrics sampler
- Previously, a warning message was sometimes emitted which was related to the garbage collection runtime metrics sampler. This has been fixed.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.10.0

Thu, 24 Apr 2025 00:00:00 +0000

Notes

This release of the Python agent adds support for async elasticsearch, fixes a graphql configuration parsing issue, fixes a bug in the Kombu instrumentation and re-enables the Kombu instrumentation.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add async support for elasticsearch
- Adds support for async elasticsearch. Thanks fagnerzulin for the contribution!

Bug fixes

Add parsing of graphql config setting
- Previously, when the setting instrumentation.graphql.capture_introspection_queries was set in the config file, this setting did not take effect. This has been fixed.
Fix crash in Kombu when running with Sentry
- Fixes a crash in Kombu instrumentation where a TypeError was raised from the inspect module. This bug was due to a conflict in wrapping between New Relic and Sentry. The Kombu instrumentation has also been re-enabled.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.11.0

Thu, 01 May 2025 00:00:00 +0000

Notes

This release of the Python agent adds support for Google Gemini via the Google Generative AI SDK and instruments new Kinesis methods.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for Google Gemini via Google Generative AI SDK
- Adds support for google-genai. The agent will automatically instrument embed_content calls for synchronous and asynchronous embeddings. The agent also now supports synchronous and asynchronous text generations for text inputs in non-streaming cases. This includes calls made to generate_content for single text-only inputs and calls to send_message for multi-turn conversations.
Instrument new AWS Kinesis methods
- Adds botocore instrumentation to support new AWS Kinesis methods including tag_resource, untag_resource, and list_tags_for_resource.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.12.0

Mon, 12 May 2025 00:00:00 +0000

Notes

This release of the Python agent adds support for Redis v6.0.0 and fixes conflicts with the opentelemetry-proto package.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for Redis v6.0.0
- Adds support for all client methods introduced in Redis v6.0.0.

Bug fixes

Fix conflicts with opentelemetry-proto package
- Fixes an issue where the agent's internal copy of opentelemetry-proto would conflict with any other packages relying on opentelemetry-proto (such as ChromaDB). This should now be treated as a separate package by OpenTelemetry and prevent any conflicts.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.13.0

Mon, 09 Jun 2025 00:00:00 +0000

Notes

This release of the Python agent adds support for the Model Context Protocol (MCP) and fixes import logic for importlib.metadata and pkg_resources.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for Model Context Protocol (MCP)
- Adds support for MCP calls in mcp and fastmcp. The agent will now automatically instrument the following core MCP primitives:
  - Tools (via call_tool)
  - Resources (via read_resource)
  - Prompts (via get_prompt)

Bug fixes

Fix import logic for importlib.metadata and pkg_resources
- Updates logic around import of importlib.metadata to also attempt to use the importlib_metadata backport before falling back to pkg_resources.*. This also removes use of sys.version conditionals and fixes issues where Python 3.9 could only use pkg_resources despite having importlib.metadata available.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.14.0

Wed, 18 Jun 2025 00:00:00 +0000

Notes

This release of the Python agent adds support for Azure Function Apps and protobuf v6.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Adds support for Azure Function Apps
- Adds support for Azure Function Apps for HTTPTrigger types.

Bug fixes

Adds pb2 files to enable protobuf v6 support
- Previously, several google packages were not compatible with New Relic due to the lack of protobuf v6 support. This has now been resolved.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.15.0

Thu, 24 Jul 2025 00:00:00 +0000

Notes

This release of the Python agent adds support for oracledb, fixes a bug in Kombu and Kafka where MessageTransaction object has no attribute destination_name, and fixes the disappearance of utilization metadata with AWS.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Adds support for oracledb
- Add instrumentation for oracledb.

Bug fixes

Fix "MessageTransaction object has no attribute destination_name" bug
- Fix a bug in MessageBroker instrumentations where the serialize methods were looking for the destination_name attribute on the MessageTransaction and it did not exist.
Fix AWS utilization metadata issue when running AWS and K8s together
- Due to permissions settings in K8s pods running on AWS EC2 instances, the utilization metadata is able to be retrieved the first time. However, if the application is left running continuously, the agent will reconnect and the utilization metadata fails to load. In cases like these, the utilization metadata is cached per agent instance and is able to be retrieved.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v10.16.0

Thu, 14 Aug 2025 00:00:00 +0000

Notes

This release of the Python agent adds support for new Redis functions, convert all internal paths from os.path to pathlib.Path, and fixes an issue with JSON encoding PosixPaths.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Adds support for new Redis functions
- Add instrumentation for new Redis functions.
Convert all internal paths from os.path to pathlib.Path
- Convert all internal usage of string based paths and os.path to pathlib.Path in preparation to support Windows paths.

Bug fixes

Fix issue with JSON encoding PosixPath
- Some users were experiencing issues with JSON encoding PosixPath configuration settings. This issue has been fixed.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v1.0.2.130

Mon, 14 Nov 2011 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

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.

Python agent v10.17.0

Thu, 04 Sep 2025 00:00:00 +0000

Notes

This release of the Python agent adds support for the following:

Custom tasks in Celery
Graphene-Django monitoring
Middleware filtering in Django
AWS Bedrock Converse API
W3CTraceParent header sampled flag

This release also provides the following fixes:

Safeguards for the deepest unique path in GraphQL
Safeguards for web URL request parsing
Fallback for ElasticSearch and GraphQL when trace.settings==None
Remove options method from async ElasticSearch client list

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Adds support for custom tasks in Celery
- Add monitoring support for custom task classes in Celery. Previously, only tasks using the default task class were able to be monitored. Note: This version of the Python agent will no longer support Celery versions less than v5.2.0.
Adds support for Graphene-Django
- Add monitoring support for synchronous schemas created with Graphene-Django. Previously, schemas created with Graphene-Django would only be partially monitored, resulting in missing GraphQL related attributes.
Adds support for middleware filtering in Django
- Users are now able to filter which Django middleware to monitor. There are now three additional settings:
  - instrumentation.middleware.django.enabled (Default is true)
  - instrumentation.middleware.django.exclude
  - instrumentation.middleware.django.include
See the Django Middleware Filtering page for more information and examples.
Adds support for AWS Bedrock Converse API
- Add monitoring support for non-streaming Converse API. This includes support for converse chat completion calls made using boto3 and aioboto3 clients.
Adds support for W3CTraceParent header sampled flag
- When an upstream service sends the W3CTraceParent header with the sampling flag set, New Relic will take into account that sampling decision when deciding whether the current transaction will be sampled.
Added support for sampling decisions based on whether the remote parent is sampled
- Added support for two new configuration options:
  - distributed_tracing.sampler.remote_parent_sampled
  - distributed_tracing.sampler.remote_parent_not_sampled
- default is the default behavior and behaves as it did before this change (it passes the sampling decision to the adaptive sampling algorithm to determine whether the transaction will be sampled).
- always_on means that the trace that has a remote parent sampled or remote parent not sampled will always be sampled.
- always_off means that the trace that has a remote parent sampled or remote parent not sampled will never be sampled.

Bug fixes

Add safeguard for deepest unique path in GraphQL
- Some users were experiencing issues with the deepest unique path in GraphQL not being generated due to a field name returning None. This issue has been fixed.
Add safeguard for web request parsing
- Some users experienced a parsing error when request_uri was malformed or contained invalid characters. This can happen at this point if the request_uri in the request header is invalid and does not match the (valid) URL originally given. While this safeguard has now been put in place in New Relic, urllib has resolved this issue for versions of Python released after Jan 31, 2025.
Fix crash in ElasticSearch and GraphQL when trace.settings==None
- In cases where trace.settings is None, the instrumentation for ElasticSearch crashed the application. A global_settings fallback has been put in place. This also resolves the same issue found in GraphQL.
Remove options method from async ElasticSearch client list
- The previous instrumentation of ElasticSearch caused a crash because options was in the list of async methods. This method is no longer wrapped in a DatastoreTrace since it is not one that conducts any datastore operations/requests.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v1.0.3.138

Tue, 15 Nov 2011 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Fixes:

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'.

Python agent v1.0.5.156

Wed, 30 Nov 2011 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Fixes:

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.

Python agent v11.0.1

Mon, 06 Oct 2025 00:00:00 +0000

Notes

This release of the Python agent provides fixes for early activation in Django instrumentation, server side overrides for max_samples_stored being ignored, and guards against crashes from trace_cache.pop().

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Bug fixes

Prevents early activation in Django instrumentation
- Remove calls to application_settings() in Django instrumentation to prevent issues with early activations in pre-fork applications.
Fix server configuration to local configuration sync issues
- This fixes a bug created when event_harvest_config.harvest_limits.* settings were deprecated in favor of *.max_samples_stored settings. Some server side configurations were not overriding the client side configurations, resulting in data being sent to the collector despite the user disabling this.
Guard against crashes from trace_cache.pop()
- In the ContextOf class, there was an unsafe access of the trace_cache via pop(key) without a default value. This caused crashes when the weakref in the dictionary was already garbage collected.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v1.10.0.28

Wed, 23 Jan 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent contains a fix for when reporting to multiple applications, as well as other minor bug fixes and enhancements.

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

New features:

On the Linux platform, the agent environment now reports the total amount of system memory available.
Added support for psycopg2cffi database module.
Custom parameters can be associated with function trace nodes for display against transaction traces in the UI.
The URL associated with a call to an external service will now be shown in the custom parameters section for the node in a transaction trace. Previously would have been shown as a label when hovering other the node.

Bug fixes/Improvements:

The agent was not reporting any data where multiple applications were being listed in in the app_name configuration setting.
Calling register_application() in the context of a module import could cause a temporary deadlock when a timeout period was specified. The potential for deadlock will now be detected and the function will return without waiting.
When the agent was configured to capture query string parameters, a key with an empty value was being discarded and not reported.
When using gevent mode of gunicorn, the SystemExit exception was being logged on process shutdown due to gevent sending the SystemExit exception to all greenlets and not just the main thread when sys.exit() was called.
Instrumentation wrapping the Django reverse() function was not accepting named parameters.
If custom parameters were used with a transaction, the HTTP response STATUS was duplicated in details related to an error raised from that transaction.
Changes to Django instrumentation to avoid metric grouping issues resulting from raw URLs leaking through as transaction name.

Python agent v11.0.0

Thu, 25 Sep 2025 00:00:00 +0000

Notes

This version of the agent has been withdrawn.

This release of the Python agent makes the following changes:

Removes support for Python 3.7
Removes and or deprecates various APIs and settings
Deprecates aioredis instrumentation
Raises the minimum supported version of setuptools and setuptools_scm
Adds new instrumentation for AutoGen
Adds new instrumentation for Pyzeebe
Adds new MCP (Model Context Protocol) named spans
Fixes a crash in psycopg
Ensures MCP spans are only recorded when AI monitoring is enabled

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Removed features

Removes support for Python 3.7
- Python 3.7 was EOL'd June 27, 2023. The Python agent has dropped support for it.

Removes various deprecated APIs

The following APIs have been removed:

Legacy API	Replacement API
`accept_distributed_trace_payload`	`accept_distributed_trace_headers`
`add_custom_parameter`	`add_custom_attribute`
`add_custom_parameters`	`add_custom_attributes`
`create_distributed_trace_payload`	`insert_distributed_trace_headers`
`get_browser_timing_footer`	The functionality of this has been wrapped into `get_browser_timing_header()`
`record_exception`	`notice_error()`
`NewRelicLogHandler`	`NewRelicLogForwardingHandler`
`lambda_handler` & `LambdaHandlerWrapper`	These APIs have moved to the `newrelic-lambda` package.

Removes various deprecated settings

The following settings have been removed:

Legacy Setting	Replacement Setting
`transaction_tracer.capture_attributes`	`transaction_tracer.attributes.enabled`
`error_collector.capture_attributes`	`error_collector.attributes.enabled`
`browser_monitoring.capture_attributes`	`browser_monitoring.attributes.enabled`
`analytics_events.enabled`	`transaction_events.enabled`
`analytics_events.capture_attributes`	`transaction_events.attributes.enabled`
`error_collector.ignore_errors`	`error_collector.ignore_classes`
`strip_exception_messages.whitelist`	`strip_exception_messages.allowlist`
`ssl`	This is now hardcoded to `true` so it has been removed as a setting option.
`ignored_params`	Use `newrelic.attributes.exclude = request.parameters.{name}` instead. Add each request parameter key to the `newrelic.attributes.exclude` list, delimited by commas. Be sure to prepend the key with `request.parameters`.
`agent_limits.merge_stats_maximum`	This is now completely ignored in favor of serverside config.

Deprecated features

Instrumentation for aioredis has been deprecated
- The aioredis package has been deprecated in favor of redis which now includes the submodule redis.asyncio. As a result, the instrumentation for aioredis has also been deprecated. Please use the redis library instead. This instrumentation will be removed in a future release.

Deprecates some existing harvest settings to match other language agents

In order to be more consistent with the conventions of the other language agents, the following harvest settings are now deprecated:

Legacy Setting	Replacement Setting
`event_harvest_config.harvest_limits.analytic_event_data`	`transaction_events.max_samples_stored`
`event_harvest_config.harvest_limits.span_event_data`	`span_events.max_samples_stored`
`event_harvest_config.harvest_limits.error_event_data`	`error_collector.max_event_samples_stored`
`event_harvest_config.harvest_limits.custom_event_data`	`custom_insights_events.max_samples_stored`
`event_harvest_config.harvest_limits.log_event_data`	`application_logging.forwarding.max_samples_stored`

This is a revert of a previous change that renamed these settings from *.max_samples_stored to the event_harvest_config.harvest_limits.* form. This decision has been reversed, and the original settings named have been restored to match the other language agents who did not change these settings names. The deprecated settings will continue to work for now, but they will be removed in a future release.

Deprecates configuration of the agent through the WSGI environ dictionary
- The following settings which were previously possible to configure through the WSGI environ dictionary are now deprecated. Please configure these settings through environment variables or the config file.
  - newrelic.set_background_task
  - newrelic.suppress_apdex_metric
  - newrelic.suppress_transaction_trace
  - newrelic.capture_request_params
  - newrelic.disable_browser_autorum
Deprecates support for building the agent with setuptools<61.2 or setuptools_scm<6.4
- The minimum supported versions of setuptools and setuptools_scm have been increased to 61.2 and 6.4 respectively. This is to support the use of pyproject.toml for configuring the package metadata and building instructions. The agent can now be built with more modern build tools which will no longer log warnings about the lack of a pyproject.toml file.
- This change adds new version attributes to the packages, newrelic.__version__ and newrelic.__version_tuple__, which can be used to programmatically check the version of the agent at runtime.

New features

Adds new instrumentation for AutoGen
- Adds instrumentation (named spans and custom Llm events) for agents and tools in AutoGen
Adds new instrumentation for Pyzeebe
- Adds automatic instrumentation and framework-specific agent attributes for Pyzeebe
Adds new MCP (Model Context Protocol) named spans
- Adds new named spans for MCP (Model Context Protocol) tool calls made via tool manager to support Streamable HTTP

Bug fixes

Fixes a crash in psycopg>=3.2.0 when calling as_string()
- Fixes an issue in psycopg>=3.2.0 where the as_string() method no longer required arguments, causing a potential crash. This has been fixed, and both signatures of this method are supported.
Ensures MCP (Model Context Protocol) spans are only recorded when AI monitoring is enabled
- Ensures MCP (Model Context Protocol) spans are only recorded when the setting ai_monitoring.enabled is enabled.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v1.10.1.36

Fri, 22 Feb 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent contains improvements in the way that queueing time is calculated.

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

Bug fixes/Improvements:

Resolved some issues with tracking of front-end queue time, particularly when the agent is running on an app hosted on Heroku. The agent will now more reliably parse the headers described in https://newrelic.com/docs/features/tracking-front-end-time and will automatically detect whether the times provided are in seconds, milliseconds or microseconds.

Python agent v1.10.2.38

Sat, 23 Feb 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent fixes an issue when floating point values were used in headers used to calculate queueing time.

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

Bug fixes/Improvements:

When a float value was provided in the X-Request-Start or X-Queue-Start headers as the time stamp, it was not being parsed correctly and the fractional part was being discarded. This was resulting in loss off accuracy.

Python agent v11.1.0

Mon, 03 Nov 2025 00:00:00 +0000

Notes

This release of the Python agent adds Python 3.14 support, new environment variables for attribute filter settings, support for async generators in transaction decorators, additional models in AWS Bedrock, and new methods in AWS Kinesis. This release also fixes a bug in aiomysql which caused RecursionError when using ConnectionPool where it was wrapped multiple times, a bug where properties were not properly passed in kombu's producer, and an error when shutdown_agent is called from within the harvest thread.

Install the agent using easy_install/pip/distribute via the Python Package Index, using conda via the Conda-Forge Package Index, or download it directly from the New Relic download site.

Features

Add support for Python 3.14
- Add support for Python 3.14.

Add environment variables for attribute filters settings

The following settings now have the option to be set through environment variables:

Configuration Setting	Environment variable
`attributes.enabled`	`NEW_RELIC_ATTRIBUTES_ENABLED`
`attributes.exclude`	`NEW_RELIC_ATTRIBUTES_EXCLUDE`
`attributes.include`	`NEW_RELIC_ATTRIBUTES_INCLUDE`
`browser_monitoring.attributes.enabled`	`NEW_RELIC_BROWSER_MONITORING_ATTRIBUTES_ENABLED`
`browser_monitoring.attributes.exclude`	`NEW_RELIC_BROWSER_MONITORING_ATTRIBUTES_EXCLUDE`
`browser_monitoring.attributes.include`	`NEW_RELIC_BROWSER_MONITORING_ATTRIBUTES_INCLUDE`
`error_collector.attributes.enabled`	`NEW_RELIC_ERROR_COLLECTOR_ATTRIBUTES_ENABLED`
`error_collector.attributes.exclude`	`NEW_RELIC_ERROR_COLLECTOR_ATTRIBUTES_EXCLUDE`
`error_collector.attributes.include`	`NEW_RELIC_ERROR_COLLECTOR_ATTRIBUTES_INCLUDE`
`span_events.attributes.enabled`	`NEW_RELIC_SPAN_EVENTS_ATTRIBUTES_ENABLED`
`span_events.attributes.exclude`	`NEW_RELIC_SPAN_EVENTS_ATTRIBUTES_EXCLUDE`
`span_events.attributes.include`	`NEW_RELIC_SPAN_EVENTS_ATTRIBUTES_INCLUDE`
`transaction_events.attributes.enabled`	`NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_ENABLED`
`transaction_events.attributes.exclude`	`NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_EXCLUDE`
`transaction_events.attributes.include`	`NEW_RELIC_TRANSACTION_EVENTS_ATTRIBUTES_INCLUDE`
`transaction_segments.attributes.enabled`	`NEW_RELIC_TRANSACTION_SEGMENTS_ATTRIBUTES_ENABLED`
`transaction_segments.attributes.exclude`	`NEW_RELIC_TRANSACTION_SEGMENTS_ATTRIBUTES_EXCLUDE`
`transaction_segments.attributes.include`	`NEW_RELIC_TRANSACTION_SEGMENTS_ATTRIBUTES_INCLUDE`
`transaction_tracer.attributes.enabled`	`NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_ENABLED`
`transaction_tracer.attributes.exclude`	`NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_EXCLUDE`
`transaction_tracer.attributes.include`	`NEW_RELIC_TRANSACTION_TRACER_ATTRIBUTES_INCLUDE`

Add support for async generators in transaction decorators
- Previously, transaction decorators did not support being wrapped around async generators. This support has been added, and async generator transactions will now automatically measure event loop wait time and other statistics.
Add support for additional models in AWS Bedrock instrumentation
- Updates AWS Bedrock instrumentation through botocore and aiobotocore to support the following additional models
  - Claude Sonnet 3+ models
  - Models that are prefixed with a region (region-aware)
Add instrumentation for new Kinesis methods
- Adds botocore instrumentation to support new AWS Kinesis methods
  - describe_account_settings
  - update_account_settings
  - update_max_record_size
  - update_stream_warm_throughput

Bug fixes

Prevent a RecursionError in aiomysql ConnectionPool
- Previously, a RecursionError would be raised in aiomysql when using pooled connections. Deep ObjectProxy chains were created around pooled connections due to repeated wrapping. This has been fixed.
Fixed a bug where properties were not properly passed in kombu's producer
- Fixed a bug where instrumentation for kombu.messaging.Producer.publish() was causing properties to accidentally be nested inside of the dictionary, causing the properties to be in the wrong spot and not read by downstream packages.
Fix error when shutdown_agent is called from within the harvest thread
- Previously, a RuntimeError could occur when shutdown_agent was called from within the harvest thread. This fixes that issue by adding a guard to prevent the crash.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v11.3.0

Thu, 22 Jan 2026 00:00:00 +0000

Notes

This release of the Python agent adds new ways of passing errors to notice_error(), adds support for Strands-Agent synchronous tool error capturing, adds support for gpt-5 and newer OpenAI LLM models, and fixes a crash in Azure Functions' utilization logic.

Install the agent using easy_install/pip/distribute via the Python Package Index, using conda via the Conda-Forge Package Index, or download it directly from the New Relic download site.

Features

Add support for exception instances as arguments to notice_error()
- notice_error() can now accept a caught exception instance (such as one from a try/except block) for the error argument, rather than an exception tuple from sys.exc_info().
- This is in addition to and does not replace the existing behavior. Previous usage of notice_error() with zero arguments or with an exception tuple should still function correctly.
Add support for gpt-5 and newer OpenAI LLM models
- Add updates to OpenAI instrumentation to support newer attribute names used with later OpenAI models
Add support for Strands-Agent synchronous tool error capturing
- Synchronous Python functions used as tools in Strands-Agents now have proper error capturing, and capture traces within tools such as database lookups.

Bug fixes

Guard against crashes in Azure Functions utilization
- Previously, some users experienced edge cases where Azure Functions utilization detection would crash when attempting to match regular expressions. The crash has been fixed, and should no longer be possible in the future.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v1.1.0.192

Tue, 10 Jan 2012 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Fixes:

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.

Python agent v11.4.0

Thu, 29 Jan 2026 00:00:00 +0000

Notes

This release of the Python agent adds support for LangGraph agents.

Install the agent using easy_install/pip/distribute via the Python Package Index, using conda via the Conda-Forge Package Index, or download it directly from the New Relic download site.

Features

Add support for LangGraph agents
- Adds instrumentation for LangGraph agent invocations via create_agent() in LangChain. This includes agent calls to invoke(), ainvoke(), stream(), and astream().

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v11.2.0

Mon, 08 Dec 2025 00:00:00 +0000

Notes

This release of the Python agent adds support for the following:

Strands
AWS Bedrock Converse Streaming
Redis methods hybrid_search and msetex
Langchain role assignments for LLM events
LLM event timestamp captured at time of LLM request
loop_factory parameter in asyncio.Runner

This release also addresses a bug in ASGI instrumentation where headers are not reported by the web server.

Install the agent using easy_install/pip/distribute via the Python Package Index, using conda via the Conda-Forge Package Index, or download it directly from the New Relic download site.

Features

Add support for Strands
- Add instrumentation for Strands tools and agents in single and multi-agent (swarms, graphs, etc.) setups
Add support for AWS Bedrock Converse Streaming
- Add monitoring support for streaming Converse API. This includes support for Converse chat completion calls made with boto3 and aioboto3 clients using converse_stream().
Add support for Redis methods
- Add support for the following methods:
- hybrid_search
- msetex
Add support for loop_factory in asyncio.Runner
- In Python 3.11, the asyncio.Runner class was added as well as the loop_factory parameter. The loop_factory parameter provides a replacement for loop policies. Now, the loop that is created is instrumented, regardless of whether it is through a global event loop setting or a custom event loop.
Capture Langchain role assignments in LLM events
- Langchain LlmChatCompletionMessage events now contains the assigned role from Langchain.
Capture LLM event timestamp at time of LLM request
- Previously, the LLM event's timestamp was captured at the time of event creation. Now, it is more accurately captured at the time of the LLM request.

Bug fixes

ASGI header consumption
- When an ASGIWebTransaction consumes the headers from a http.response.start event, it was doing so without regard to the allowable input types. When the headers are a generator, the generator was consumed by the call to process_response() leaving no headers remaining for the web server to send. This has now been fixed.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v1.13.1.31

Fri, 05 Jul 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent includes a hot fix to address an issue whereby external web service calls made via HTTPS connections were failing. This issue was introduced with version 1.13.0.30 of the agent.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directory from our download site.

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

Bug fixes/Improvements:

The Cross Application Tracing feature added in version 1.13.0.30 of the agent was causing failure of external web service calls made over HTTPS connections when that call was made via the 'httplib' module. As the 'httplib' module is used internally in other HTTP client libraries such as the 'urllib', 'urllib2', 'urllib3' and 'requests' modules, they would also have been affected.
Setting the 'cross_application_tracer.enabled' setting in the agent configuration file to 'false' to disable Cross Application Tracing would cause an exception when an external web service call was being made via the 'httplib' module.

Python agent v1.11.0.55

Tue, 09 Apr 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent introduces a major new feature called X-Ray Sessions. This feature allows you to gain deeper insights into a key transaction's performance by showing transaction traces alongside long-running profiler results.

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

New features:

X-Ray Sessions provide more targeted transaction trace samples and thread profiling for web transactions. For full details see our X-Ray sessions documentation.
For new agent installations, the agent will now default to using a SSL connection when connecting to our data collector to report any data. If updating from an older agent version, you will however need to manually update your agent configuration file and change the 'ssl' setting to 'true' to always use SSL connections.
When connecting direct to our data collector over a SSL connection, SSL certificate validation will now be performed to mitigate the possibility of man in the middle attacks.
Breakdown metrics for transactions are now recorded as unscoped metrics as well as the existing metrics scoped to a web transaction. As custom dashboards can only chart unscoped metrics, what this means is that it is now possible to create custom dashboards that display data on specific breakdown metrics, such as time spent in traced functions. For example, you may wish to chart time spent in creating database connections, or specific middleware and view handler functions.
When displaying error details, the full path of the exception is now displayed and not just the class name. This makes it easier to correctly identify the full name, with that name then being able to be directly copied into the 'error_collector.ignore_errors' setting of the agent configuration file if it is desired that that exception be ignored.
Added the 'newrelic.agent.record_custom_metrics()' function to the public API for the agent to allow the recording of many custom metrics in one function call to the agent.

XXXFeatures Changed:

We have temporarily disabled the generation of CPU burn information for transaction traces. This was displaying inaccurate values after a UI change, but also had an underlying issue whereby it was reporting CPU burn by the whole process and not just the thread handling the request. We are withdrawing the feature until we can improve the accuracy of the reported value.
We have disabled the ability to get thread profiling information when a WSGI server makes use of coroutine libraries such as gevent or eventlet. This is because the nature of how coroutines are implemented, means we were are not able to generate accurate usable data.

Bug fixes/Improvements:

When queueing Celery tasks from a web application, those web transactions were in some cases being wrongly categorised as background tasks. The name of the transaction was also being labelled with a string with the object representation, resulting in metric grouping issues.
The older version of the 'requests' package we were bundling and were using for any HTTP calls was not closing socket descriptors immediately when a requests session object was disposed of. This could result in a small number of open socket descriptors being held open until the Python garbage collector kicked in and closed them.
Login credentials supplied as part of a URL, could in some circumstances appear with the URL parameter associated with a web external node in a transaction trace sample.
Django 1.5 moved which module the 'Http404' exception was declared in. As a result we were no longer correctly ignoring it when catching exceptions to process as errors.
A check designed to warn against the use of uWSGI versions prior to 1.2.6, which contain a bug which results in the agent recording incorrect response times, was failing on very old uWSGI versions.
Updated our gevent instrumentation to accommodate a prototype change in gevent 1.0rc1.
Updated our bottle instrumentation to handle the non numeric version string used in bottle development versions.
After five minutes of being unable to connect to our data collector to report data, the agent will now internally reset itself, discarding accumulated metric data and require the agent to reregister itself with our core application before collecting data once again. This is to ensure that we do not unnecessarily keep accruing data and causing an increase in memory usage while we cannot contact our data collector.
Avoid the potential for a web request to deadlock in a situation where a web framework transaction management system made a copy of the object we use to record details about web transactions or background tasks.

Python agent v11.5.0

Thu, 19 Feb 2026 00:00:00 +0000

Notes

This release of the Python agent adds trace/span support for Hybrid Agent, New Relic's integration with OpenTelemetry. It also adds entity GUIDs to Agent Control health check files, subcomponent attributes to agentic AI instrumentation, support for new Redis client methods, fixes a bug where there may be duplicate ImportHookFinder instances and a bug in OracleDB Cursor.callproc() instrumentation.

Install the agent using easy_install/pip/distribute via the Python Package Index, using conda via the Conda-Forge Package Index, or download it directly from the New Relic download site.

Features

Add Hybrid Agent tracing support
- Hybrid Agent is designed to bridge the gap for teams looking to adopt OpenTelemetry standards while maintaining backwards compatibility with their existing New Relic dashboards. Hybrid Agent offers a "best-of-both-worlds" experience by combining New Relic’s deep visibility with OpenTelemetry API compatibility. It provides an observability solution with integrated support for the following OpenTelemetry APIs:
  - Tracing
  - Standalone library and native framework instrumentation
- Key enhancements like Span Links and Events on Spans are now available, ensuring seamless interoperability in mixed-mode environments.
Introduces a new Trace ID Ratio based sampler
- A new Trace ID Ratio based sampler. This sampling algorithm is based off the sampler of the same name from OpenTelemetry, and can be configured to sample a set percentage of transactions.
Add subcomponent attributes to agentic AI instrumentation
- Instrumentation for LangChain, MCP, and Strands now includes a subcomponent attribute on spans that represent tool or agent calls. This is used to provide more enhanced entity mapping in the New Relic UI.
Add entity GUID to Agent Control health check files
- When the agent is started within an Agent Control environment, a health check file is created at the configured file location for every agent process. This file now includes the GUID of the entity related to the agent when available.
Add instrumentation for new Redis methods
- Add instrumentation for the following methods new methods on Redis clients:
  - hotkeys_get
  - hotkeys_reset
  - hotkeys_start
  - hotkeys_stop
  - vrange
  - xcfgset

Bugs

Fix duplicate ImportHookFinder instances
- Previously it was possible for duplicates of the import hook finder to be added to sys.meta_path.
Fix incorrect signature on OracleDB Cursor.callproc()
- Previously attempting to use keyword arguments with Cursor.callproc() would cause crashes as the argument names were incorrect in our instrumentation. This has been fixed, and the additional argument keyword_parameters is now also supported.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v1.12.0.56

Tue, 28 May 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent removes the experimental label from our Tornado Web and Pyramid support, with support now being enabled by default.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directory from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

New features:

The previously experimental support for the native Tornado Web API has been greatly expanded and is now enabled by default. This is in addition to the tornado.wsgi.WSGIContainer support we previously provided and includes the native Tornado Web API for constructing async applications. Running a limited subset of the native Tornado Web API within a separate WSGI server using the tornado.wsgi.WSGIApplication adapter is also now supported.
The previously experimental support for the Pyramid web framework has been improved and is now enabled by default.
When using a DBAPI2 compliant database client, calls to stored procedures via the callproc() method of the database cursor are now tracked. Previously, only calls made to stored procedures by explicitly using a CALL SQL statement were being tracked. All calls to stored procedures currently appear under the category of 'SQL - Other'. A future agent update is planned which will split out calls to stored procedures separately and report them on the databases tab.
Added instrumentation for automatically wrapping the WSGI application when using the CherryPy WSGI server bundled with the CherryPy framework.
Added instrumentation for automatically wrapping the WSGI application when using the WSGI server from the Python standard library wsgiref module. Be aware that due to non conformance with the WSGI specification, it is not recommended that the WSGI server from the wsgiref module be used unless using Python 2.7.4 or higher. Issues with older versions of the WSGI server in the wsgiref module will cause incorrect reporting of data. More details are provided in our status of the Python agent.

Bug fixes/Improvements:

External web calls made using the 'requests' module from a session were not being correctly monitored, resulting in such requests being picked up as being performed by the lower level 'httplib' module and the time taken not being inclusive of the whole request.
The collection of explain plans by the agent in a background thread when performing a data harvest, was not explicitly performing a rollback. This could result in database proxies such as pgbouncer believing the database connection was now dirty and force closing the connection and ejecting it from the current database connection pool.
The wrapper used by the agent around wsgi.input passed in the WSGI request environment was preventing non standard WSGI applications directly reaching down to the original socket connection so as to implement extensions such as websockets.
The object wrapper used in our instrumentation for function traces has been improved so that it will pass type checks performed using builtin Python calls such as isinstance(), isfunction() and isclass(). This addresses issues where the object wrappers could interfere with the correct operation of web frameworks which derived the calling convention to be used when invoking a handler function from the type of the handler. Note that using type() on the wrapper object will still yield its true type, so functions such as isinstance() should always be used where possible.
The agent could fail on startup when running on a system with a non English locale using a custom date/time format.

Python agent v1.2.0.246

Tue, 27 Mar 2012 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

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.

Python agent v1.13.0.30

Wed, 03 Jul 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent adds support for Cross Application Tracing.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directory from our download site.

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

New features:

Support for New Relic's Cross Application Tracing feature is now available for the Python agent. This feature enables correlation of transaction traces between different services in your stack. It works on external calls made between applications monitored by any New Relic agents (Java, .NET, Ruby and Python), which support this feature. At this time the Python agent supports this feature on outgoing calls when using the 'httplib' module or any other module which uses 'httplib', such as the 'urllib', 'urllib2', 'urllib3' and 'requests' modules. Any inbound calls from other agents which support the feature will also be handled.
Added instrumentation for the weberror package. This provides visibility into potentially blocking operations such as sending of email for exceptions which are being reported.
Added instrumentation for the umemcache package.
Added instrumentation for the DBAPI2 compliant interface for the IBM DB2 ibm_db_dbi database client package.

Bug fixes/Improvements:

When running a WSGI application under the Tornado WSGI container, data reporting would stop if an unhandled exception managed to propagate back up to the Tornado WSGI container. This was due to a bug in Tornado in respect of its compliance with the WSGI specification. A workaround is provided to avoid the problems this caused to the Python agent. Tornado versions prior to 3.2 will still carry that bug however and we make no attempt to address the bug in Tornado.
The Tornado instrumentation was causing template rendering to fail where a relative path was used to refer to the template and no template path had been specified for the RequestHandler instance or globally.
The Tornado instrumentation was causing exceptions when using the @tornado.gen decorators under Tornado 2.X.
When using Django, web transactions will now be named after individual view handlers when using class based views, rather than being named after the class itself.
When using Pyramid, web transactions will now be named after individual view handlers when using view classes, rather than being named after the class itself.
Celery instrumentation had stopped working correctly for Celery versions 2.5.3 through 2.5.5.
No data was being reported where a monitored process was being shutdown within a couple of seconds of being started even if the agent was able to register. This could result in custom metrics in particular not being reported.
SSL certificate validation was failing on older Debian systems due to the OpenSSL libraries not being able to process a couple of the certificates bundled with the Python agent. Those certificates were not required and have been removed.
Calculation of a time string was failing on Windows due to using a strftime() formatter which only existed on UNIX systems.

Python agent v1.3.0.289

Tue, 12 Jun 2012 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes:

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.

Python agent v1.2.1.265

Wed, 25 Apr 2012 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

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.

Python agent v1.4.0.137

Wed, 01 Aug 2012 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes:

This release of the Python agent introduces a number of new features including improvements to RUM browser traces. Performance of the agent has also been improved though reducing some of the overheads when dealing with tracking SQL database queries.

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

New features:

The agent now collects additional application tier transaction trace samples for slow transactions and will correlate them with any corresponding RUM browser trace.
Slow transaction traces will now show a figure corresponding to the amount of CPU burn that occurred during the period the transaction was running. This can be used to get an indication of whether code being executed was CPU intensive or principally waiting on I/O.
Slow transaction traces for web requests will now provide an indication of how many concurrent requests were executing at the same time in the process the request was being handled. This can be used to determine how busy the process was at that time, but would also be used in conjunction with the recorded CPU burn to determine whether CPU burn was all from the one transaction or could also be due to parallel executing web requests in a multithreaded application. Note that this measure is dependent on an optional C extension component of the agent being able to be installed at the time of installation of the agent.
Slow transaction traces for web requests will now display information about the amount of request content read and the amount of response content generated. This will include details about what methods of 'wsgi.input' were used to read content and how long it in total took to read the request content. Similar details are also provided about how response content was generated and how long it took from start to finish.
Slow transaction traces for web requests will now display the value of any frontend queueing time within the server stack which pertained to that specific request. Note that this is dependent on the server stack having being configured to introduce the required header to allow queueing time to be measured. The Python agent recognises the 'X-Queue-Start' header.
Automatic support is now provided for tracking frontend queueing time within the server stack when an application is deployed to Heroku.
An API call and means via the WSGI environ dictionary is now provided for indicating that a transaction should not be a candidate for slow transaction traces. This is to allow one to ignore transactions which are known to always be slow. The API call is 'newrelic.agent.suppress_transaction_trace()'.
Calls to Django APIs for sending emails will now be tracked in the performance breakdown for transactions, as well as being displayed in slow transaction traces.
Support for Celery 3.0.

Bug fixes/Improvements:

Overheads within the agent which could affect performance of the application have been reduced. The improvements specifically revolve around the processing of SQL database queries. This is principally to address larger than expected overheads seen by a very small subset of users which had large or more complicated SQL queries. The changes could though still result in a small general reduction in overhead and CPU usage directly attributable to the monitoring down by the agent when SQL database queries are being tracked.
Where it is possible to build C extension components at the time the agent is installed, optional C speedups for JSON will now be installed. This reduces the overhead of JSON encoding when data is being sent by the agent to the New Relic data collector on each one minute harvest cycle. If the C extension cannot be compiled, the agent will fall back to using pure Python code as it has done in prior versions of the agent.
Django instrumentation has been improved and issues addressed with the way that instrumentation wrappers were applied to view handlers. For example, when a view handler is passed to a view middleware, any instrumentation wrapper is now removed. This is because the wrapper could cause issues for some code which tried to do a direct comparison between the view handler passed and an expected value. It is believed this change will fix issues when using Mezzanine.
A sporadic issue with the data collector rejecting uploaded data due to what it believes was malformed JSON should be addressed. This was due to some metric values being aggregated as integers rather than as float values. This resulted in overflow of 64 bit values in the data collector due to Python supporting arbitrary length integers and thus being able to send values larger than 64 bits.
The agent will now no longer fail on import when -OO option is used with the Python interpreter to enable highest level of optimisation. This was an issue as -OO strips documentation strings from code and the agent was not handling the case that the documentation string would then be a None object.

Python agent v1.5.0.103

Tue, 04 Sep 2012 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes:

This release of the Python agent contains capacity analysis reporting, an improved sampling algorithm to ensure a wider sampling of slow transactions and added support for TastyPie, dropbox and facepy modules.

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

New features:

Enable capacity analysis reporting where web application is single threaded or multithreaded (but not coroutine based system such as gevent and eventlet). This report helps you determine if you have enough instances deployed to keep up with request load and so tune your configuration for optimal performance.
Criteria by which slow transaction samples are captured has been changed so as to include slow transactions for a broader range of transactions. Previously the transaction with the slowest overall response time would always be captured and reported. Whether a specific transaction will be preserved as a sample of a slow transaction will now also depend on whether a recent slow transaction had already been captured for it and give preference to recording slow transactions for a different transaction, rather than the same transaction all the time, if it is always the slowest.
Where TastyPie is being used with Django, instead of all web transactions being handled by TastyPie being labeled against the TastyPie wrapper, the web transactions will now be aggregated against the specific methods of the resource or API object handling the request.
Added instrumentation for the 'dropbox' Python module to track time spent calling out to the DropBox web service. A call to this web service would have been tracked previously by virtue of the 'dropbox' module internally using the 'httplib' module. This added instrumentation however makes the data collected more accurate as will properly track time spent sending the request and receiving the response. It will also attribute the call to the 'dropbox' module in transaction traces and performance breakdown data.
Added instrumentation for the 'facepy' Python module to track time spent calling out to the Facebook web service. A call to this web service would have been tracked previously by virtue of the 'facepy' module internally using the 'requests' module. This added instrumentation however allows the call to be attributed to the 'facepy' module in transaction traces and performance breakdown data.
Added support for gevent < 0.13.7 by way of patching an existing bug in gevent. The specific problem in gevent was patched in version 0.13.7 of that package. This change will allow older versions of gevent to also be used if there is a requirement.

Bug fixes/Improvements:

Instrumentation for Genshi templates was failing when the OR operator was used inside of a template.
If an exception occurred in the first call to read data from wsgi.input to get the request content, it would cause a subsequent exception when recording of response time was being finalised. This wasn't causing any impact on user requests, but would result in any metrics for that request being discarded and an error being logged in the agent log.

Python agent v1.6.0.13

Tue, 16 Oct 2012 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes:

This release of the Python agent is a minor feature and bug fix release.

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

New features:

When reporting web application performance data against multiple applications in the New Relic UI at the same time, any end user metric data will now also be reported against all applications. Previously end user metric data would only be reported against the first application.
The environment variable 'NEW_RELIC_SSL' can now be set to enable use of a SSL connection when reporting data to our data collector. Enabling values are 'true', 'on' or '1'. This can be used on platforms such as Heroku where configuration is performed using environment variables instead of an agent configuration file.
Added instrumentation for tracking database queries when using the 'pymysql' module for the MySQL database.

Bug fixes/Improvements:

Fix to algorithm calculating name of function for case where function was wrapped with a decorator implemented using a class. Previously was using the name of the decorator class rather than the name of the wrapped function.
Fix for ZeroDivision error when calculating per request CPU burn, where due to clock granularity for system the request was quick enough to effectively have zero duration.
Fix for AttributeError when trying to process None as a slow transaction trace when in a harvest period there were browser traces but no application server traces.

Python agent v1.8.0.13

Wed, 14 Nov 2012 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes:

This release of the Python agent enables the ability to set apdex values and alerts for key transactions (discussed here)

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

New features:

Added support in the agent required to enable apdex values to be specified for key transactions.
Added support for tracking SQL database queries when using the 'oursql' database client module for MySQL.

Bug fixes/Improvements:

The sqlite3 instrumentation was preventing the use of a sqlite3 database connection object as a context manager together with the 'with' statement.
Suppressed the logging produced by the urllib3 module included within the bundled requests module, when making socket connections.

Python agent v1.7.0.31

Wed, 07 Nov 2012 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes:

This release of the Python agent focuses on providing a low-overhead thread profiler which can monitor and record executing threads for a specified time, without affecting the customer experience.

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

New features:

Low-overhead thread profiler. A profiling session can be initiated for a period from 2 to 10 minutes. The profiler will periodically sample what all the executing threads are doing, aggregating the results together to get a statistical snapshot of where in your application most time is being spent.

Bug fixes/Improvements:

Importing of the greenlet module was resulting in the capacity analysis report metrics being disabled, even though it was meant to only be disabled when specifically using a coroutine based WSGI server such as gevent and eventlet mode of gunicorn.
Improvements to the instrumentation wrapper applied to the Django view handler function so that code which tries to compare the view handler to an expected value should work. Note that this is dependent upon using an equality test rather than an identity test.
Reverted prior change which stripped the instrumentation wrapper from the Django view handler when it was passed to any Django view middleware. Improvements to the instrumentation wrapper should remove the need to do this. Having the view handler passed in with the wrapper applied is required to ensure that calls to the view handler are tracked properly where the view handler is called from within the view middleware.
Although not strictly required due to improvements to the instrumentation wrapper applied to a Django view handler, strip the wrapper when a view handler is passed into django.core.urlresolvers.reverse() function to ensure it can correctly determine the URL mapping to the view handler.
Disable automatic RUM header/footer insertion when using Django 1.5 and the new streaming HTTP response object is returned. This is being disabled so that the response is not buffered, thereby interfering with the streaming process. If streaming a HTML response and RUM reporting is still required, the RUM header and footer will need to be added manually.
Instrumentation of the feedparser module was causing an exception when a file like object rather than a string was passed to the feedparser.parse() function.
Tastypie instrumentation was failing to be applied if using Python 2.5.

Python agent v1.9.0.21

Wed, 19 Dec 2012 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes:

This release of the Python agent addresses an issue with under reporting of memory use on Linux, as well as other minor bug fixes and enhancements.

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

New features:

Added support for automatically wrapping the WSGI application entry point when using the Paste HTTP server.
Custom metrics can now be reported via the public agent API by supplying an appropriate application object as an additional argument to 'newrelic.agent.record_custom_metric()'.
Added support for the 'psycopg2ct' database client module for PostgreSQL.
When needing to communicate via a firewall, the proxy settings can now be set via environment variables in addition to being able to be set in the agent configuration file.
The number of CPU cores is now being reported in the agent environment and displayed in the UI.
A warning will now be logged in the agent log file if an older version of uWSGI is being used which has bugs with its conformance to the WSGI specification. Such older uWSGI versions would see incorrect data being reported due to the bug in uWSGI.
A warning will now be logged in the agent log file if uWSGI is being used and the 'enable-threads' option is not being supplied to uWSGI to enable threading within the Python interpreter, a feature which is a mandatory requirement for the Python agent to be able to work.
A range of additional logging and debugging options have been added to allow our support team to better help you when you are having issues with setting up the agent.

Bug fixes/Improvements:

Addressed problem where memory usage was being under reported on Linux systems. The degree to which memory usage was under reported was dependent on the memory page size the system was using. If affected you can expect to see memory usage being reported jump up as it reports the correct value.
If the local Python installation is already using a 'sitecustomize.py' file, the agent's own 'sitecustomize.py' file will ensure that the existing copy is imported and code in it executed so that existing definitions are still applied.
Installation of the agent could fail under buildout due to a missing Python future import for the Python with statement under Python 2.5.
Made parsing of URLs more tolerant to malformed URLs in web external calls. The agent was encountering an error when the port number of a URL was not an integer, resulting in the data for that transaction being discarded.
Use of raw greenlets from within a transaction was failing causing an exception and the users web request to typically fail with a HTTP 500 error response.
Configuration of the agent will no longer fail on startup if there is no 'newrelic' section in the configuration file.

Python agent v2.0.0.1

Wed, 04 Sep 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent is a major new version and primarily focuses on the addition of support for Python 3.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directory from our download site.

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

New Features:

Python 3.3 or later is now supported. This includes support for popular web frameworks that have been ported to Python 3, such as CherryPy, Django, Flask, Pyramid and Tornado.
Added new instrumentation to track as external service calls, requests made by the 'thrift' client module.
Added new instrumentation to track memcache calls made by the 'bmemcached' client module.

Features Removed:

Python 2.5 is no longer supported. The minimum required Python version is now 2.6. If using Python 2.5, you should ensure that any requirement for the 'newrelic' module listed in a 'setup.py' or pip requirements file says 'newrelic<2.0.0.0'.

Bug fixes/Improvements:

Fixed broken instrumentation for 'httplib' module, which would cause an exception where the 'httplib' connect() method was being invoked via the Connection class type rather than an instance of the Connection class.
Fixed issue where if the host system clock was wound backwards, then the response time of active requests could be set as being zero, resulting in a ZeroDivisionError when calculating thread utilization.
Fixed issue where the use of SSL via a HTTP proxy by the agent to connect to the New Relic data collector to report data would fail.
Fixed broken instrumentation for sqlite database client module which resulted in the executescript() API call failing.
Add workaround for uWSGI issue where when using gevent mode of uWSGI, it would attempt to wait on all greenlets on process shutdown, instead of only on non daemon threads, specifically the request threads. The issue was causing processes to hang for 60 seconds on shutdown before the uWSGI master process killed the process. We are in discussion with uWSGI authors about a permanent fix to uWSGI.

Python agent v2.100.0.84

Tue, 09 Jan 2018 00:00:00 +0000

Notes

This release of the Python agent contains security related updates as well as bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Security Updates

See the associated security bulletins for custom API parameters in high-security mode and for SQL params for SQLite.

Bug Fixes

Using the aiohttp client may result in an application crash

Under certain circumstances, using the aiohttp client may have resulted in an application crash. This issue has been addressed.
Database queries made with psycopg2 may not have been recorded

When using the "with" statement to create a cursor, time spent on database calls may not have been properly recorded. This issue has been addressed.
Usage of the pika library resulted in a memory leak

When using the pika library with New Relic, Channel objects would not be cleared from memory as expected. This would result in abnormally high memory utilization in some cases. The memory leak has now been fixed.
DeprecationWarning generated for async/await keywords

Using the agent may have generated a DeprecationWarning around async/await being reserved keywords. The DeprecationWarning should no longer be generated.

Python agent v2.10.1.9

Fri, 24 Jan 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent is a hot fix version to address an issue related to cross process application traces introduced in 2.10.0.8.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directory from our download site.

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

Bug fixes/Improvements:

The value of headers inserted into the HTTP response returned from the WSGI application to support cross process application tracing were being incorrectly passed as Unicode strings on Python 2. This would cause a strictly compliant WSGI server such as Apache/mod_wsgi or uWSGI to raise an error when the headers were being set. In general, pure Python WSGI servers are not as strict in their WSGI compliance and would have silently accepted the value anyway, converting it to a byte string using the Python system default encoding.

Python agent v2.102.0.85

Mon, 05 Feb 2018 00:00:00 +0000

Notes

This release of the Python agent contains improvements to the time tracing API as well as bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Time Trace API Improvements

Time trace APIs (such as function_trace) can now be used with coroutines

The following decorator APIs can now be used with native coroutines and generators:
- function_trace
- database_trace
- datastore_trace
- external_trace
- message_trace
- memcache_trace
Example:
```
@function_trace(name='my_coroutine')
async def my_coroutine():
  await asyncio.sleep(0.1)
```

Bug Fixes

gRPC instrumentation used on Python 2.x can cause a memory leak

When using gRPC on Python 2, gRPC futures would not be garbage collected resulting in a memory leak. gRPC futures will now be garbage collected.
Instrumentation for Dropbox v8.0 and newer caused error log messages

Dropbox client version 8.0 or higher raised instrumentation errors. These errors did not prevent metrics on Dropbox from being sent. These errors have been removed.
Values from negated ranges were sometimes added to ignore_status_codes

Negated status codes not found in the current ignore_status_codes were added if they were part of a range of values. This issue has been addressed.

Python agent v2.10.0.8

Fri, 17 Jan 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent includes various improvements and bug fixes related to instrumentation for database client modules, as well as a notable fix to our 'newrelic-admin' script affecting some users who referenced Python virtual environments via a symbolic link.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

New Features:

Instrumentation of the WSGI application entry point will now add a new breakdown metric to web transactions corresponding to the finalization of the WSGI request. Within the workings of the interaction between the WSGI server and the WSGI application, this is the point at which the WSGI server will call any close() method on the iterable returned by the WSGI application. The name of this new breakdown metric is 'WSGI/Finalize'. In the case where there was actually a 'close()' method, a further breakdown metric will also appear corresponding to that method.
Added support to instrumentation for MySQL and PostgreSQL database client modules for monitoring database queries when the database connection object is used as a context manager. Such context manager features are outside of the scope of the Python DBAPI2 (PEP 249) specification, not all database client modules support it and nor do they all work the same. Although supported, we would suggest consideration should be given to not using these context manager features if you need your code to be portable between databases.
Added support to instrumentation for MySQL database client modules for monitoring database queries when the database connection object was created using the Connect() function. The Connect() function falls outside of the scope of the Python DBAPI2 (PEP 249) specification. Although supported, we would suggest consideration should be given to not using this Connect() function if you need your code to be portable between databases.
Added database instrumentation support for the mysql-connector-python database client module.
Custom parameters for a transaction which are a string or numeric value will now be added to and reported with analytic events reported to our analytics system code named Rubicon. This can be disabled using the agent configuration setting 'analytics_events.capture_attributes'.
The capture of custom parameters against a transaction trace can now be disabled using the agent configuration setting 'transaction_tracer.capture_attributes'.
The capture of custom parameters against error details can now be disabled using the agent configuration setting 'error_collector.capture_attributes'.

Features Changed:

The agent API function add_user_attribute() is now deprecated and functionality merged with the add_custom_parameter() function. The latter function should now be used instead. The display of such parameters in browser traces is now optionally enabled with the agent configuration setting 'browser_monitoring.capture_attributes'.

Bug fixes/Improvements:

If the 'newrelic' package was installed into a Python virtual environment, but the 'newrelic-admin' script was executed via a path that traversed a symlink to the virtual environment, the protections within the agent bootstrapping procedure was detecting that the agent was trying to be used with an application running against a different virtual environment when it was actually the same. This would result in the application not being monitored. This issue was introduced in version 2.8.0 of the agent when additional protections were added against mixing application/modules from different Python virtual environments.
Explain plans were not being performed on SQL queries made via the executemany() method of a database cursor object. When explain plans are now done, the data inputs from the first row of input data for the executemany() call will be used.
When using Python 2, if strings were supplied for the web transaction name, custom parameters, in error details etc, and that string contained a series of characters which could not be decoded as valid UTF-8, then an exception would occur. In the case of a web transaction name, this could result in the exception affecting the current web transaction and result in an error response being sent back to a user. For the case of a transaction trace or error details, the exception would prevent the sending of the captured data up to our data collector and it would be discarded. This was a regression within the agent behaviour introduced when Python 3 support was added to the agent.
Fixed instrumentation for sqlite database modules which could result in instrumentation not being applied correctly, and so no database metrics collected, if the sqlite module had been imported prior to the agent being initialized.
Limits being applied to the length of the SQL for a slow SQL query when being sent up to our data collector were being applied at the wrong time, resulting in the truncated SQL being used when performing an explain plan. This didn't affect the operation of the web application, but database logs could contain an error about the malformed SQL query.
Explain plans could be attempted for an SQL query even where the SQL query failed. Under most circumstances a SQL query would fail immediately and so the duration would fall below the threshold for collecting an explain plan, but the changes now made will protect against a long running SQL query which failed in the database and ensure that no additional problem is caused by issuing an explain plan for it.
If a monitored web application is started up using our newrelic-admin wrapper script, and it executes a separate Python script and that Python script used a Python version older than Python 2.6, the script could output the error message "'import site' failed; use -v for traceback". The execution of the script was not affected, but the message obviously could cause concern.
The equivalent functions from the 'urllib2' module from Python 2 were not being instrumented when Python 3 was being used. This was missed when Python 3 support was added to the agent.

Python agent v2.104.0.86

Tue, 20 Feb 2018 00:00:00 +0000

Notes

This release of the Python agent adds a deprecation warning for customers that disable SSL, and adds bugfixes for supported async frameworks that use asyncio.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Mandatory SSL

Disabling SSL connections to New Relic has been deprecated

SSL connections are enabled by default. In a future release, the option to disable SSL will be removed.

Bug Fixes

Using asyncio.gather or asyncio.ensure_future now tracks transaction context

Prior to this release, using asyncio.gather or asyncio.ensure_future may result in certain traces (such as external calls) not being reported in the transaction. Traces scheduled with asyncio.gather or asyncio.ensure_future from within the context of a transaction should now be properly attributed to the transaction.

Python agent v2.106.0.87

Wed, 28 Feb 2018 00:00:00 +0000

Notes

This release of the Python agent adds support for AIOHTTP version 3.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Improved AIOHTTP Support

Support for AIOHTTP 3

AIOHTTP major version 3 is now supported by the New Relic Python agent.

Python agent v2.106.1.88

Wed, 07 Mar 2018 00:00:00 +0000

Notes

This release of the Python agent includes a fix for security bulletin nr18-07.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Python agent v2.12.0.10

Mon, 03 Feb 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent includes improved instrumentation for the Bottle framework and new instrumentation support for gevent WSGI servers. It also allows reporting of data to multiple applications in New Relic to be specified via an environment variable, in addition to the existing 'app_name' setting in the agent configuration file.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

New Features:

Provide automatic instrumentation of the WSGI application entry point when using the 'gevent.wsgi' and 'gevent.pywsgi' servers. This means that if you are not using a web framework we already support and instrument, are using a WSGI component library, or implementing your WSGI application from scratch, it is no longer necessary to wrap the WSGI application entry point with our special decorator or wrappers when using the gevent WSGI servers.

Features Changed:

Previously it was only possible to list multiple applications in New Relic to report data to via the 'app_name' setting in the agent configuration file. Attempting to list multiple application names (separated by the requisite semi colon), in the 'NEW_RELIC_APP_NAME' environment variable was ignored with the complete value (including semi colons), being used as the application name. This limitation has now been lifted and a list of applications to report to can now be specified using the 'NEW_RELIC_APP_NAME' environment variable.

Bug fixes/Improvements:

The instrumentation for the Bottle web framework has been improved. The changes include the request handler now being broken out properly as a separate item in the transaction breakdown, the web transaction being named after an error handler when appropriate and requests which could not be mapped to a request handler being named as being a 404 if no error handler was provided. Handling of exceptions for HTTP errors has also been improved and are now being correctly matched against our internal list of HTTP status codes to be ignored as exceptions. Previously the instrumentation was too liberally ignoring all HTTP error exceptions.
When using the Flask web framework, a NotFound exception raised within the underlying Werkzeug library was not being ignored. It is now no longer necessary to explicitly ignore the exception type 'werkzeug.exceptions:NotFound' in the agent configuration.
When an unhanded exception was raised by a Pylons application, a bug in the implementation of the agent's error trace wrappers would cause a subsequent exception to be raised from the agent itself, masking the details of the original exception.
When trying to determine how much memory was available on a system, the agent would fallback to trying to the use the 'psutil' module, if installed, if our standard ways of checking failed. This would cause the agent to fail on a PaaS such as PythonAnyWhere, which prohibits access to the /proc filesystem. Use of 'psutil' as a fallback has now been removed to avoid any potential for a failure.
The version of the bundled 'requests' module the agent used to perform HTTP requests to our data collector did not work with Python 2.6.2 or older. A fix to 'urllib3' used by the 'requests' module has been back ported to address the issue.
Our updated database instrumentation wrappers released in the last agent version, would incorrectly return that a database connection or cursor object were callable. This could confuse code which was trying to introspect those objects to perform traversal in order to get access to inner details of the implementation of the database modules.

Python agent v2.14.0.11

Mon, 17 Feb 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent adds support for the Cornice REST component library for the Pyramid web framework, as well as a number of minor feature improvements and bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

New Features:

Instrumentation added for the Cornice REST component library for the Pyramid web framework.

Bug fixes/Improvements:

Enhance the instrumentation for the Bottle web framework to work around the problem that the Bottle framework was not using 'functools.wraps()' correctly in the implementation of its 'auth_basic()' decorator. This was resulting in the web transaction being named after the 'wrapper' function closure used in the implementation of the decorator rather than the wrapped request handler the decorator was applied to. A pull request was made against the Bottle framework and the change will be included in a future version of Bottle. Our change ensures that the correct result is also obtained with older Bottle versions.
When using the database connection object created by the sqlite3 database client module as a context manager, the automatic rollback or commit performed by the context manager when the scope of the context manager is exited, will now be tracked.
If a function trace was applied to the bound method of a class implemented in a C extension module, the name of the module shown in the name of the function was being wrongly designated as the Python 'builtins' module.
Updated memcache instrumentation wrappers to use our latest function wrapper implementation. Our latest function wrappers better preserve the ability to introspect wrapped functions/methods and so return the same result as one would expect if no wrapper had been applied.

Python agent v2.18.1.15

Fri, 28 Mar 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent adds improved audit logging functionality and an admin script sub command for recording deployments.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

New Features

Record Deployments: A new 'record-deploy' sub command has been added to the 'newrelic-admin' script installed with the Python agent. This is a wrapper around the HTTP API provided by New Relic for recording deployments against your application. To use the sub command, add your API-KEY in the agent configuration file under the 'api_key' setting. The path to the config file, description for the deploy and optional revision, change log and user information can then be supplied as arguments to the sub command.
Audit Logging: An improved audit logging feature has been added to the agent for capturing details of what is being sent up to our data collectors. Information is now captured into a separate log file in a more human-readable format to aid any review process carried out to determine what the agent is sending. The audit logging feature can be enabled by setting the the 'audit_log_file' setting in the agent configuration file, or the 'NEW_RELIC_AUDIT_LOG' environment variable. It is not recommended that audit logging be enabled for any extended period as the resulting log file will be quite large.

Bug fixes/Improvements:

The agent now ensures that the certificate bundle packaged with the agent is always used when certifying SSL connections back to our data collector. Previously the location of the certificate bundle could be overridden by a number of environment variables. This could cause SSL connection failures when the referenced certificate bundle didn't exist or had incorrect permissions and could not be accessed.

Python agent v2.16.0.12

Wed, 05 Mar 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent adds obfuscation of explain plans as the default when using PostgreSQL, as well as including bug fixes related to the instrumentation for some MySQL database client modules.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

Bug fixes/Improvements:

Fixes an agent bug with PostgreSQL where parameters from the original query could appear in explain plans sent to New Relic servers, even when SQL obfuscation was enabled. Parameters from the query are now masked in explain plans prior to transmission when transaction_tracer.record_sql is set to 'obfuscated' (the default setting).
The automatic rollback or commit performed on exit of the context manager for a database connection was not being monitored and reported when using the MySQLdb, pymysql and oursql database client modules for the MySQL database.

Python agent v2.20.0.17

Thu, 29 May 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent provides various improvements to database client module instrumentation and execution of explain plans.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

New Features

Added a 'license-info' command to the 'newrelic-admin' script for displaying the LICENSE file for the 'newrelic' package.

Bug fixes/Improvements:

The bottle instrumentation was causing a secondary exception when a web request was not actually being monitored and an un-handled exception occurred in the web request.
Added support for accepting additional arguments to the execute() method of database cursors implemented by the oursql and cx_Oracle modules which are not covered by the Python DBAPI 2 (PEP 249) specification.
The time taken for connect() calls of database client modules will now be counted in Database time (on the APM Overview page).
The automatic rollback or commit performed on exit of the context manager for a database connection was not being monitored and reported when using the psycopg2, psycopg2cffi and postgresql database client modules for the PostgreSQL database.
Improved how database connections are managed when performing explain plans and also applied caps to the number of process wide explain plans that are done in each reporting period. This should have the result of reducing overhead in situations where there was a large number of candidate SQL statements on which to perform explain plans. Any additional overhead from the agent in the past would have been most notable when performing an X-Ray session against a key transaction.

Python agent v2.20.1.18

Fri, 13 Jun 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent addresses a bug which in some cases caused database connection parameters, which could include login credentials, to be logged to the local system by the monitored application if Python agent debug logging is being captured.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

Bugs Fixed

When Python agent debug logging was enabled by setting log_level to debug in the Python agent configuration, database connection details, including login credentials could be logged in the local Python agent log file.

The details may also have been logged even if log_level had not been set to debug, but the Python logging module had been configured to collect and log messages logged at the log level of logging.DEBUG.

This issue was introduced in version 2.20.0.17 of the Python agent.

Python agent v2.2.0.2

Fri, 11 Oct 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent is an incremental release and includes minor feature changes and enhancements.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directory from our download site.

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

New Features:

Use of HTTP proxies over SSL using the HTTP CONNECT tunnelling mechanism is now supported. Set the 'proxy_scheme' to 'http' to invoke this mode. This will become the default in a future version of the agent. If migrating from an older agent version and need to keep the existing behaviour going forward, set 'proxy_scheme' to 'https'. Alternatively, ensure you provide the scheme in the form of a URI as part of the 'proxy_host' setting.
Added request queueing support to the instrumentation for the Tornado ASYNC framework. Request queueing times should start showing in the APM Overview page when a frontend web server such as Nginx, has been configured to add the appropriate headers. For more details see our documentation on setting up tracking of queueing time.
The 'newrelic.agent.record_exception()' can now be called without actually passing it any exception details. In this case, the details of any current exception being handled will be used instead.
Added a new mechanism for automatic discovery of third party instrumentation modules as an alternative to having to list them explicitly in the agent configuration file. Any such instrumentation module should register entry points under the 'newrelic.hooks' group in 'setup.py' for that package. The entries should be of the form 'target-module = instrumentation-module:function'. When the 'target-module' is imported, the function 'instrumentation-module:function' will be executed and passed the module. Any instrumentation module should then use functions provided by our agent API under 'newrelic.agent' to instrument the module as necessary.

Bug fixes/Improvements:

When using the CherryPy web framework, the NotFound, InternalRedirect and HTTPRedirect exceptions if raised are now ignored and not treated as errors.
When using the Pyramid web framework, if a view could not be found to handle a request, it could cause the agents' Pyramid instrumentation to fail, causing an exception.
When using the Pyramid web framework, the PredicateMismatch exception if raised when trying to resolve a URL to a view handler is now ignored and not treated as an error.
Updated the instrumentation for the pywapi module to drop support for the now discontinued Google weather API.
Overhauled the mechanisms used to wrap instrumentation around functions to be monitored. When the agent is installed, if the optional C extension module can be compiled and installed, then the new wrappers should have a reduced overhead compared to the pure Python versions of the wrappers otherwise used.
Running thread profiles on coroutine (gevent/eventlet) based systems no longer cause a timeout in the UI. Although the UI now no longer times out, as explained in our status of the Python agent documentation, we still however do not generate any results when running thread profiling on coroutine based systems.

Python agent v2.2.1.3

Fri, 11 Oct 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent is a hot fix version to address a Celery instrumentation issue introduced with version 2.2.0.2.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directory from our download site.

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

Bug fixes/Improvements:

Fixed bug with Celery instrumentation introduced with version 2.2.0.2 of the agent. The bug was causing a Python exception to be raised when the instrumentation was trying to derive the task name to use as the name of the background task.

Python agent v2.22.1.20

Tue, 01 Jul 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent is a hot fix release to address an issue introduced in version 2.22.0.19 when applying additional function traces from the agent configuration.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

Bug fixes:

When using the transaction_tracer.function_trace setting in the agent configuration file to apply additional function traces, the trace was not being applied and a message indicating an instrumentation error would appear in the Python agent log file. The error in itself would not have prevented the agent from starting and running, but no data would be collected for the designated functions as intended.

Python agent v2.22.0.19

Tue, 24 Jun 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent introduces a means to enforce High-security mode from the agent configuration, as well as enabling capture of Insights events for background tasks.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

New Features:

Insights events are now also recorded for background tasks, in addition to the existing events already captured for web transactions.
The application to record an exception against can now be explicitly provided using the keyword argument application when calling newrelic.agent.record_exception(). This enables the ability to record exceptions outside of the context of a monitored web transaction or background task. A suitable application object can be retrieved using newrelic.agent.application().

Features Changed:

Enforcing High-security mode from the agent configuration is now supported.

High-security mode is a feature to prevent any sensitive data from being sent to New Relic. The local setting for the agent must match the server setting in the New Relic APM UI. If there is a mismatch, the agent will log a message and act as if it is disabled. A link to the docs for High-security mode can be found here

Attributes of high-security mode (when enabled):
- Requires an SSL connection to be used.
- Prevents capture of request parameters.
- Suppresses capture of custom parameters.
The default setting for High-security mode is false.

If you already have high-security mode enabled within the New Relic APM UI, you will need to add:
```
high_security = true
```
to your local agent configuration file.

Or if using Heroku, set the NEW_RELIC_HIGH_SECURITY environment variable by running:
```
heroku config:set NEW_RELIC_HIGH_SECURITY=true
```
When using the gunicorn WSGI server, the request URL which appears in transaction trace samples and error details will now be sourced from the RAW_URI variable passed by gunicorn in the WSGI environ dictionary. This will ensure that what is displayed is the raw URL before % escape sequences have been decoded. This avoids the problem of the URL being shown as a raw byte sequence.
When audit logging is enabled, the responses returned from our data collector service will now also be logged.

Bug fixes/Improvements:

An incorrect module name was being derived for methods of classes, when used in web transaction and function trace naming, where the method was from a base class defined in a different module, but invoked via a derived class.
When using Django class based views, if a class based view was used explicitly from within a view handler, the name of the class based view method was overriding the web transaction name, which at that point would have been set to the view handler. The class based view method name will now only be used for the web transaction name when it is actually registered as the view handler.
Explain plans for SQL queries were not working when the SQL database cursor had been configured to return a dictionary rather than a tuple for each row set when the original query was made.

Python agent v2.26.0.22

Wed, 20 Aug 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent includes improvements to browser monitoring, with the primary change being that the Python agent is now able to perform automatic browser monitoring for a wider range of Python web frameworks running on a traditional WSGI server. This includes popular web frameworks such as Flask, Pyramid and Bottle.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

New Features

Prior to this version, automatic browser monitoring for HTML pages served up by a Python web application was only available if using the Django web framework. With this release this capability has now been expanded in most cases to cover any Python web framework being hosted on top of a web server with a direct interface for hosting Python WSGI applications. WSGI servers this covers include the popular Python web hosting packages Apache/mod_wsgi, gunicorn and uWSGI. Support does however not currently extend to Python web hosting mechanisms which provide a bridge to a WSGI application from a native Python web application API, such as is the case if using the Tornado or Twisted WSGI containers.

What the change means is that if using a previously unsupported web framework such as Flask, Pyramid or Bottle, and you were not manually instrumenting your HTML page responses to make use of browser monitoring, you will now start to see automatically end user performance metrics being captured and displayed in the New Relic APM UI. You will also have access to the optionally enabled browser monitoring agent, enabling access to details of AJAX calls made by your pages and also the details of any client side Javascript errors which might have been raised.

If you were previously manually instrumenting your HTML page responses to enable browser monitoring, you should in most cases now be able to discontinue such manual instrumentation.

Note that at this time, in addition to lack of support for Tornado and Twisted WSGI containers, we do still have a few restrictions in place which mean we may not always be able to enable automatic browser monitoring support. The key restriction is that when using a web framework, the automatic support for browser monitoring will be disabled if you are using a middleware or plugin for the framework, which performs compression of responses, or which otherwise modifies the content encoding for the response. For example, automatic browser monitoring will still not be available if using the flask.ext.compress plugin with Flask, or the paste.gzipper middleware with any WSGI application. We are working on extending coverage to cases where such middleware or plugins are being employed, but if you are using them, for now you will still need to resort to manually instrumenting your responses to enable browser monitoring. The only exception to this is the Django web framework, where we already previously had support for automatic browser monitoring even if the Django GZipMiddleware was being used.

For further details on the updated browser monitoring support and manually instrumenting your HTML page responses, see our documentation on page load timing when using the Python agent. If browser monitoring support is not currently enabled for your application or you need to disable it, then see our documentation on browser settings.

Bug fixes/Improvements

The agent was in some cases incorrectly inserting our instrumentation to HTML page responses which were marked as an attachment by way of a Content-Disposition HTTP response header or HTML page meta tag.

Python agent v2.24.0.21

Wed, 06 Aug 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent includes fixes related to tracking of external web service calls and minor improvements to automatic real user monitoring HTML insertion for Django. An offline developer mode has also be added to verify the operation of the agent with your application in a development or test environment.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

New Features

An offline developer mode for the agent now exists to allow for verification that the operation of the agent will not affect the monitored web application in a development or test environment, without sending any actual data to New Relic. As it is an offline mode, no additional hosts will be recorded against your New Relic account for billing purposes.

The offline mode does not allow for any viewing of collected metric information and other data for the purposes of monitoring your application, so it is not a solution for running New Relic locally. Being able to run it however, will allow you determine if a newer version of the agent, or an upgrade of any third party package in conjunction with the agent, will still function correctly before you jump to upgrading the packages in your production environment.

The offline developer mode can be enabled by setting the developer_mode setting in the agent configuration file, or the NEW_RELIC_DEVELOPER_MODE environment variable, to true.

Audit logging can also be enabled in conjunction with the offline developer mode so as to allow for the investigation of what data would be set to New Relic, resulting from the monitoring of your application, without actually sending any data to New Relic.

Audit logging itself can be enabled by setting the the audit_log_file setting in the agent configuration file, or the NEW_RELIC_AUDIT_LOG environment variable. It is not recommended that audit logging be enabled for any extended period as the resulting log file will be quite large.

Bug fixes/Improvements

When using the Bottle web framework, the setting error_collector.ignore_status_codes, for ignoring exceptions linked to specific HTTP response status codes, was being ignored in the case of using Bottle plugins and a plugin raised a HTTPError exception. This only affected Bottle versions 0.11 or higher.
The New Relic feature for cross application tracing between two monitored web applications was not working when a Python web application was using recent versions of the urllib3 and requests modules for initiating the call to the backend web application service. This affected version 1.8 or higher of urllib3 and version 2.3.0 of the requests module.
External web service calls were not being monitored when using the prepared requests feature of the requests module directly.
When using the urllib or urllib2 modules, if a URI of the form file://..., corresponding to a local file on the file system, was passed to any function monitored by our instrumentation, a metric and transaction trace node were being generated corresponding to an external web service with host name of 'unknown'. The instrumentation now correctly filters out URIs which do not correspond to an actual remote web service.
The automatic means for inserting page load timing tracking code for real user monitoring (RUM) into HTML page responses returned from a Django application now works no matter the case used for HTML elements. Previously automatic insertion would only be performed where HTML elements were lower case.
RUM tracking code inserted automatically into HTML page responses from Django is now more optimally placed when a X-UA-Compatible meta tag appeared in the head element of the HTML page. Previously the RUM code was placed at the end of the head element when such a meta tag existed. This would have meant that page loading times would not have accurately reflected time spent in loading assets from any script elements appear after the meta tag. The RUM code is now placed immediately after the meta tag. Placement is not done before the meta tag as some browsers require that the meta tag appear prior to any script elements.
RUM tracking code inserted automatucally into HTML page responses from Django is now placed after any Content-Type meta tag which also contains a charset attribute. This is necessary as some browsers will not recognise such a meta tag if it does not occur early in the page content. If a script tag was therefore placed before this meta tag it could have resulted in the meta tag being pushed down sufficiently far enough in the page content so as not to be recognised.
Data corresponding to a long running transaction monitored by the agent, which spanned the time when a server side configuration change was made in the New Relic UI, will now be discarded. This is to avoid a problem where the response time average for web requests on the overview chart would be skewed so as to appear greater at the time a server side configuration change was made. This problem would result as when such a server side configuration change is made, the agent will momentarily disconnect and reregister. In that time, any short lived transactions would not be monitored, but the long running transaction which only completed after registration occurred was incorrecly being recorded, with an undue effect on average response times.

Python agent v2.26.2.24

Mon, 25 Aug 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent is a hotfix release to prevent proxy credentials set in the agent configuration file from being transmitted to New Relic.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent see Status of the Python agent.

Bug fixes

Previously, the agent stripped the proxy_user and proxy_pass settings when it transmitted configuration settings to New Relic, so as not to expose credentials. However, the proxy_host setting was transmitted unaltered, even if it was a URI containing a username and/or password. With this release, proxy usernames and passwords specified in a URI in the proxy_host setting are obfuscated before being transmitted. In addition, the proxy_user and proxy_pass settings are obfuscated, and are also transmitted.

Python agent v2.28.0.26

Tue, 26 Aug 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent improves data collection with the Django web framework. These improvements include better-targeted web transaction naming with the Django REST framework, better coverage of Django template inclusion tags, and better background task monitoring for Django management commands.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent see Status of the Python agent.

New Features

Improved Django REST Framework naming

Previously, when using the Django REST framework, web transactions were being named after the class based view that implemented the Django REST framework resources. Now, where such a view provides custom handler methods for different HTTP request method types or actions, the web transaction will be named after that custom handler method rather than the class as a whole. A new function breakdown metric will also be added for the custom handler method. This change will allow web requests using different HTTP request method types to be viewed separately.
Django inclusion tag monitoring

Usage of inclusion tags in Django templates can now be monitored and will appear in the transaction breakdown table, charts and sample transaction traces.

Due to the possibility that a large range of custom inclusion tags might be used and that they may be invoked a large number of times in tight loops, tracking of all inclusion tags may not be practical or may not produce worthwhile results in the transaction breakdown or sample transaction traces. As a result, monitoring of inclusion tags is off by default, with the preferred approach being that specific inclusion tags of interest be individually enabled through the agent configuration file.

To enable monitoring of specific inclusion tags, a new section called import-hook:django should be added to the agent configuration:
```
[import-hook:django]
instrumentation.templates.inclusion_tag = prepopulated_fields_js date_hierarchy
```
The instrumentation.templates.inclusion_tag setting within that section should then be set to a space separated list of the names of the inclusion tags to monitor. If there is any confusion over the identity of the inclusion tag, the full name of the inclusion tag function, with module name, can instead be listed. For example, data_hierarchy can also be identified using django.contrib.admin.templatetags.admin_list:date_hierarchy.

In addition to specifying the names of the specific inclusion tags, it is also possible to specify * for instrumentation.templates.inclusion_tag in order to have usage of all inclusion tags be monitored:
```
[import-hook:django]
instrumentation.templates.inclusion_tag = *
```
Enabling monitoring of all inclusion tags in this way is only recommended in development or test environments so as to get an initial idea of what inclusion tags are worth tracking. Once identified, the specific inclusion tags of interest should thereafter be listed individually in a production environment.
Better monitoring of Django management commands

Previously, the Python agent required you to manually set up the instrumentation for each specific Django management command in the agent configuration file. We have now made that easier by integrating the functionality as part of the agent itself.

Due to the limitations on what Django management commands can be monitored, you will still need to list explicitly the commands you want monitored, but it can now be done in a single location as a space separated list under the setting instrumentation.scripts.django_admin of the import-hook:django section:
```
[import-hook:django] 
instrumentation.scripts.django_admin = syncdb sqlflush
```
By default, we automatically specify the startup timeout to be 10.0 seconds when monitoring the Django management commands. If you need to override the startup timeout, you can set the instrumentation.background_task.startup_timeout setting within the same import-hook:django configuration section.

Python agent v2.30.0.27

Tue, 16 Sep 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent improves instrumentation for the Flask web framework and adds database monitoring support when using the pymssql client with a Microsoft SQL Server database.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent see Status of the Python agent.

New Features

Improved instrumentation for Flask

The Python agent now provides better web transaction naming and performance breakdown metrics when Flask style middleware are being used. This means that time spent in Flask @before_request and @after_request functions will now be broken out as their own metrics. If a @before_request function actually returns a response, the web transaction will be correctly named after that function rather than the Flask WSGI application entry point. These changes, in addition to being applied on middleware functions registered directly against the Flask application, will also work when Flask blueprints are used to encapsulate behavior.
Browser monitoring auto-instrumentation when using Flask-Compress

When the Flask-Compress package is used to perform response compression with Flask, insertion of browser monitoring tracking code into HTML responses is now automatically performed. Previously, if Flask-Compress was being used, manual instrumentation of HTML responses would have been required.
Monitoring of MSSQL database

Instrumentation is now provided for the pymssql database client module to monitor database calls made against a Microsoft SQL Server database.

Bug Fixes

When using high-security mode, the use of newrelic.capture_request_params in the per request WSGI environ to enable capture of request parameters, possibly by setting it using the SetEnv directive when using Apache/mod_wsgi, was not being overridden and disabled as required.
When using the DatabaseTrace context manager or associated wrappers explicitly to implement a custom monitoring mechanism for database calls, the instrumentation wrappers could fail with a TypeError exception when trying to internally derive the name of the database product being used.

Python agent v2.34.0.29

Wed, 15 Oct 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent provides support for Labels and Rollups, making it possible to organize your applications in the APM UI into meaningful categories.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent see Status of the Python agent.

New Features

Labels and Rollups

The Python agent now supports the ability to apply labels to applications, so that you can easily sort, filter, and page through all of the applications on your account's Applications list.

Configuration can be done in the newrelic.ini file:
```
labels = Server:One;Data Center:Primary
```
Labels can also be configured by setting a NEW_RELIC_LABELS environment variable:
```
NEW_RELIC_LABELS=Server:One;Data Center:Primary
```
More information on using labels to categorize your applications can be found in the New Relic APM documentation.
New CPU Reporting in Environment Snapshot

Previously, the Python agent captured two CPU-related values to report to the Environment Snapshot: Logical Processors and Physical Processors. Now, it captures the following three values:
- Logical Processors: The total number of hyper-threaded execution contexts available, including execution contexts that may exist on the same core. This value remains unchanged from previous agents.
- Physical Cores: The total number of physical CPU cores available, counting hyper-threaded siblings as a single core. This value was previously reported as "Physical Processors."
- Physical Processor Packages: The total number of processor packages or dies (each of which may contain multiple physical cores). This value is new with this agent release.

Bug Fixes

A "Runtime Error: transaction already active" will no longer be seen in the case where the agent created nested transaction wrappers and newrelic.agent.ignore_transaction() was called within the outer wrapper but outside the inner wrapper. Previously, this error could have also been triggered when using the WSGI environment setting for newrelic.ignore_transaction set by SetEnv in mod_wsgi.
Prior to this version, the HTTP_REFERER URL reported for a transaction contained query parameters, even if the capture_params setting was set to False. Now, the capture_params setting is respected when reporting the HTTP_REFERER URL.

Python agent v2.32.0.28

Mon, 29 Sep 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent provides a preview of a significant overhaul of our instrumentation for Tornado version 3.2 and earlier. Further improvements to our Django instrumentation are also included, allowing time spent in rendering Django sub templates to be viewed separately.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent see Status of the Python agent.

New Features

Breakout of Django template rendering

Previously when using Django templates, if the Django include tag was being used, the time spent rendering that sub template was shown under the generic Template/Render category. When the include tag is now used, a distinct metric is instead created corresponding to the rendering time for that sub template. This will appear in the transaction performance breakdown and also in sample transaction traces. In the case of sample transaction traces, as the name of the template will be included in the metric name, it now also provides additional context for understanding where any time is being spent when rendering that template.

Features Changed

Preview of improved Tornado instrumentation

Our instrumentation for Tornado version 3.2 and earlier has been experiencing a number of issues which could result in recording of data stopping and in some cases cause runtime exceptions which would affect the outcome of the executing web request. Upon investigation we found this has come about due to incremental changes in the internals of Tornado which were performed after we originally implemented the instrumentation for Tornado and which we didn't pick up as having being made. The Tornado developers have also recently released version 4.0 of Tornado. This version of Tornado has much more significant internal changes that result in our instrumentation failing completely.

Before we could embark on trying to support version 4.0 of Tornado, we deemed it necessary to completely overhaul our existing instrumentation for older versions first in order to gives us good foundation on which to then implement support for version 4.0 of Tornado. This release of the agent provides a preview of the improved instrumentation for older versions of Tornado prior to version 4.0. The new instrumentation is not enabled by default and you will need to explicitly enable it. We have provided it as an opt in change at this point to allow you to properly test with the update first and provide us with any feedback on it and any remaining issues you may find.

To enable the preview of the new Tornado instrumentation, you will need to add to the [newrelic]section of the agent configuration file the setting:
```
feature_flag = tornado.instrumentation.r2
```
If you are running on Heroku and are not using an agent configuration file, you can instead set the NEW_RELIC_FEATURE_FLAG environment variable. You can do this by running the Heroku command:
```
heroku config:set NEW_RELIC_FEATURE_FLAG=tornado.instrumentation.r2
```

Bug Fixes

When an exception was raised by a WSGI application during the yielding of response content via a generator, the recording of that web request by the agent may not be closed off properly. This would result in no further web requests handled by that thread being recorded and reported. If this occurred for all request handler threads, then no data would then be reported for the whole web process. This issue relates to behaviour of the Python garbage collector and when Python objects are destroyed. At this point in time we believe this only affects users of pypy and does not affect users of CPython as the reference counting model of CPython usually gives more deterministic behaviour around when Python objects are destroyed. We don't however rule out that it could affect CPython and may explain a situation matching this problem we have seen in a couple of cases where users were using uWSGI.
When attempting to use Tornado as a worker for gunicorn, an exception could occur on startup which would result in gunicorn failing immediately and exiting. In order to use this combination it was previously necessary to disable the gunicorn specific instrumentation related to WSGI applications by adding to your agent configuration file:
```
[import-hook:gunicorn.app.base] 
enabled = false
```
If you were using the Tornado worker with gunicorn and using this workaround, the underlying problem has now been addressed and you should be able to remove that section from your agent configuration file.
The mechanism we used for applying function wrappers for instrumentation was not being performed in the most optimal way for methods of classes. This could result in problems, including unexpected runtime exceptions, especially when trying to apply instrumentation to class methods, or methods of an existing instance of a type.

Python agent v2.36.0.30

Wed, 29 Oct 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent provides improvements to how we report agent configuration information. This enables us to better help you debug any issues you may experience with configuring the agent.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent see Status of the Python agent.

New Features

Configuration Information

Agent configuration information displayed in the New Relic UI will now reflect the final configuration used by the agent for an application. This includes the result of any server side configuration settings, which are applied on top of the agent defaults, agent configuration file or environment variables. Previously, the result of applying the server side configuration settings was not being displayed.

Bug Fixes

If running a system with a Linux 3.X kernel, the agent could fail when attempting to register with our data collector. No data would subsequently be collected or reported. This would occur for versions of Python 2 prior to Python 2.7.3 and versions of Python 3 prior to Python 3.3, if they were built on a system with a Linux 3.X kernel.

Python agent v2.38.0.31

Wed, 12 Nov 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent adds support for the mapping features of Cross Application Tracing, which provide a visualization of how requests flow through multiple applications within a distributed system.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent see Status of the Python agent.

New Features

Cross Application Tracing

The Cross Application Tracing feature is now enhanced with the aggregate transaction map visualizations. This new visualization will help users spot bottlenecks in external services and give them an end-to-end understanding of what other applications and services are called within a transaction. All agents involved in the cross application communication must be upgraded to see the complete graph.

Improvements

Tornado 3.x Instrumentation

The newly refactored Tornado instrumentation is turned on by default. This was introduced in the python agent version 2.32.0.28 under an optional feature flag. This change improves upon the stability of our Tornado instrumentation and accounts for the incremental changes introduced to the Tornado 3.x source tree. It also provides a more granular view of where the time is spent in a WebTransaction, by distinguishing the time spent doing work vs time spent waiting on a asynchronous call.

Please be advised that we currently do not have instrumentation for Tornado 4.x, but we are working to add support for it.
Capacity Analysis for mod_wsgi

The capacity analysis report shows how many instances of your web application is running and how busy they are. For a web application, the measure of how busy the application is, is calculated by looking at how much of the time the total available set of request handler threads are busy.

For the case of using Apache/mod_wsgi in daemon mode, the measure of how busy your application is, has been getting over reported due to the nature of how threads are managed by mod_wsgi. If you are using mod_wsgi version 4.1.0 or higher, this measure will now be more accurately reported as it will use information provided by mod_wsgi about the total number of request handler threads which are available, rather than trying to calculate it based on what threads have been seen to be handling requests.

Bug Fixes

In version 2.28.0.26 and 2.32.0.28 of the agent, we added new features to track template includes and inclusion tags when using the Django template rendering system. We have had a few reports that indicate that for some users, but not everyone, that the instrumentation implementing these features may be causing an ongoing growth in memory usage for the web application processes over time. Right now, we don't understand the root cause for why this might be occurring in some instances, so to be on the safe side we have disabled these two features while we investigate further.

The consequence of these features being disabled is that the web transaction performance breakdown and sample transaction traces will no longer show as a separate metric or entry where one template has been included in another. Further, if the tracking of special inclusion tags had been configured, they will also no longer be shown. We anticipate re-enabling the features once we have worked out what is occurring and made changes to ensure it does not occur again.

Python agent v2.38.2.33

Tue, 25 Nov 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent fixes a memory leak which affects our Tornado instrumentation, and which was a factor in the recent issues we had with the Django template instrumentation.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent see Status of the Python agent.

Bug Fixes

Due to an issue with the low level function wrappers we use to instrument third party Python modules, memory was being leaked and process memory usage could increase over time. This issue affects version 2.32.0 through 2.38.0 of the Python agent and has been impacting on our Tornado instrumentation.

The memory leak has also been identified as the root cause for memory leaks in our Django template instrumentation, affecting versions 2.32.0.28 through 2.36.0.30. The Django template instrumentation was disabled in the prior 2.38.0.31 release while we investigated the cause. It remains disabled by default.

Python agent v2.40.0.34

Wed, 03 Dec 2014 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent enables the collection of transaction traces for synthetic requests by default, and adds the individual trip trace visualization for Cross Application Tracing.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

New Features

Cross Application Tracing for individual transactions

Version 2.38.0.31 of the Python agent introduced aggregated transaction maps. In this release, we have built on that feature to add the ability to view an end-to-end visualization of an individual transaction, in order to better understand what backend applications and external services were called during the course of a single transaction.

Features Changed

Synthetic support enabled by default

When the Python agent added support for the collection of transaction traces for synthetics requests in version 2.32.0.28, the feature had to be explicitly enabled in the agent configuration file. With this release, support for synthetics is enabled by default.

Bug Fixes

Non ASCII characters in transaction names

If a transaction name contained a Unicode character outside of the ASCII range, the generation of the cross application tracing attributes would result in a UnicodeEncodeError. This bug affected versions 2.38.0.31 through 2.38.2.33. The issue is fixed in the current release.
Parsing SQL statements referencing the database schema

Previously, SQL statements that referenced a table from a database schema namespace, such as “schema.table_name”, would not always be parsed correctly, resulting in the table being identified as just “schema”. The agent now handles this case correctly, and the table is reported as “schema.table_name”.
Additional support for Tornado 1.X

If Tornado 1.X was being used, the instrumentation would fail at run time causing all web requests to fail. Monitoring of Tornado 1.X applications should now work correctly.

Python agent v2.42.0.35

Sun, 18 Jan 2015 00:00:00 +0000

Notes

This release of the Python agent includes bug fixes for issues with agent registration and use of proxies which could result in no data being reported.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

Bug Fixes

Agent not recovering when errors occur during registration

If the agent initially registered with our data collector successfully, but subsequently failed to upload agent setting information due to a transient backend or network issue, the agent was not recovering from the error properly. The consequence of this was that the agent would not completely start up and no data would be collected or reported by that process. The operation of the web application as a whole would not have been affected. This issue, which was introduced in version 2.36.0.30 of the agent, is now fixed.
Agent not able to connect via some proxy servers

The Python agent was not able to connect to our data collector to register when certain proxy server installations or configurations were being used. We have updated the version of the internal HTTP client library used to resolve the issue.
Identification of Python web server being used

The Python agent was incorrectly reporting the Python web server being used as Tornado when both the 'gunicorn' and 'tornado' Python modules were being imported, even if the Tornado web server module wasn't actually being used. This did not affect the operation of the agent but could lead to confusion when trying to debug deployment issues.

Python agent v2.4.0.4

Wed, 16 Oct 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent is a bug fix release primarily to address a number of issues introduced in version 2.2.0.2 which have effected a small number of users.

This version of the agent is also the minimum recommended agent version required to be able to see percentiles and histogram charts. All reporting hosts for an application must be upgraded to the minimum agent version for the feature to be visible.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directory from our download site.

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

Bug fixes/Improvements:

Fixed issues with instrumentation wrappers which caused failure of WSGI application integration for FASTCGI/SCGI/AJP using flup.
Fixed issues with instrumentation wrappers which caused failure of wrappers for external web service calls in certain uses cases.
Fixes issues with instrumentation wrappers which caused failure when queuing Celery tasks from within a web application using django-celery.
When using the ErrorTrace context manager to capture details of exceptions within a certain context, None can now be passed for the transaction and an assertion failure will not be raised. This avoids the need to check explicitly to see if a web request is being monitored and avoid using ErrorTrace where there isn't.

Python agent v2.44.0.36

Wed, 11 Feb 2015 00:00:00 +0000

Notes

This release of the Python agent includes a major update to how we capture and represent metrics for both SQL databases and NoSQL datastores. Metrics for both types of products will now be displayed in a unified "Databases" tab in the APM UI, and these metrics will also be associated with the specific product being used. In addition, we have enabled support for having key transactions on other transactions, such as background tasks.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

New Features

Unified view for SQL database and NoSQL datastore products.

The response time charts in the application overview page will now include NoSQL datastores such as Memcached, Redis and MongoDB and also the product name of existing SQL databases such as MySQL, Postgres, Oracle etc.

We also introduced a new unified view within the APM UI for visualizing time spent in queries made against SQL databases and NoSQL datastore products.

For existing SQL databases, in addition to the existing breakdown of SQL statements and operations, the queries are now also associated with the database product being used.

For NoSQL datastores such as Memcached, Redis and MongoDB, we have now added information about operations performed against those products, similar to what is being done for SQL databases.

Because this introduces a notable change to how SQL database metrics are collected, it is important that you upgrade the Python agent version on all hosts. If you are unable to transition to the latest agent version on all hosts at the same time, you can still access old and new metric data for SQL databases, but the information will be split across two separate views.
Key transactions for other transactions.

In addition to being able to create key transactions for web transactions, it is now possible to create key transactions for other transactions, such as background tasks executed by Celery.

Key transactions enable the setting of a per transaction Apdex and alerts, as well as the ability to run X-Ray sessions, including transaction specific thread profiling.
No SQL datastore instrumentation.

To complement our new unified view for SQL database and NoSQL datastore products in the APM UI, we have upgraded our existing instrumentation for Redis and MongoDB. Previously, these only provided a function breakdown in transaction summaries and sample transaction traces, but now they will report into the unified view for database and datastore products under their respective product categories.

Existing instrumentation for Memcached clients have similarly been updated, as well as new support for the pymemcache module being added.

Python agent v2.46.0.37

Wed, 04 Mar 2015 00:00:00 +0000

Notes

This release of the Python agent is a minor bug fix release, including changes which may help to reduce the incidence of spurious warnings about being able to communicate with our service.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

Bugs Fixed

Improved management of the network connection to our service
- When the agent registered itself with our data collector, it wasn't closing the socket connection immediately and instead it was holding it open for up to a minute when the first batch of data would be reported. If the socket connection was being closed remotely during that time, a BadStatusLine exception would be seen in the logs when the attempt was made to upload data.
- When the agent received an internal restart request from our data collector as the result of a server side configuration change, the socket connection wasn't being closed explicitly. In the case of CPython it would still be cleaned up and closed immediately due to reference counting, but under PyPy when it was closed was dependent on when PyPy garbage collection occurred. This could mean that the socket descriptor could stay in use for a while.
Compatibility modules for transitioning from Python 2 to Python 3

When compatibility modules for Python 2/3 migration such as pies2overrides and future were installed in a Python 2 installation, they were installing modules which mimic modules which would normally only ever exist in a Python 3 installation. The presence of these modules were confusing the agent's instrumentation mechanisms. The result of this was that use of http.client from Python 3 in a Python 2 application would fail.
Failures when making calls to external web services
- If a HTTP client module was supplied None as the value for the URL being requested, this would cause an exception when the agent was recording the data for that transaction.
- Use of the ExternalTrace context manager class directly, for recording external web services calls, would fail if there was no active transaction. This could occur in the time before the agent has successfully been able to register with our data collector.
Setting of response content length when using Django

The Django middleware installed by the agent to perform insertion of RUM monitoring code into responses, would always set the Content-Length even if it was not previously set. This could cause issues where a frontend had been set up with an expectation that Content-Length headers would never exist.

Python agent v2.48.0.38

Wed, 25 Mar 2015 00:00:00 +0000

Notes

This release of the Python agent adds instrumentation for Elasticsearch as a new datastore product and a more granular breakdown of various SQL operations in the “Databases” tab in the APM UI. In addition, the stack traces captured by the agent are now being trimmed to remove any code snippets.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

New Features

Improved SQL Breakdown

This agent release adds the ability to see the breakdown of time spent in SQL statements such as CREATE, DROP, ALTER, SET, CALL, EXEC, EXECUTE, COMMIT and ROLLBACK. Execution of stored procedures through the callproc() or CALL statements will provide further breakdown based on the name of the stored procedure.
Elasticsearch Support

Instrumentation support for the official Elasticsearch client module and the separate pyelasticsearch module have been added. Time spent in calls made to Elasticsearch will be listed in both the main overview chart, as well as in the Databases tab in the UI. Previously, calls to Elasticsearch would have been shown as time spent in external web service calls.

Features Changed

Remove code snippets in stack traces

Stack traces captured for errors and slow SQL queries will no longer include code snippets. This change is to prevent the possibility of capturing sensitive data embedded within the code. It reduces the overhead in capturing stack trace information, and also avoids a potential problem caused when the code on disk has changed in the time since the process was started.

Bugs Fixed

Ensure that messages sent to the data collector containing parts which were already compressed and encoded, were not being compressed a second time at the HTTP request level causing additional overhead.
Guard against a potential agent error where an invalid URL was being passed to an instrumented external web service client.
Motor (an asynchronous MongoDB library) incorrectly returns a non string object when the agent tries to access the __name__ attribute on Motor objects. This caused the agent to fail when calculating the name for an object, since we rely on this value being a string as specified by the Python object model definition. The agent now overrides the incorrect behavior of Motor to ensure that we can still generate names of objects correctly.
When using Python 3 and audit logging was enabled, if messages being sent to our data collector were large enough that they were being compressed at the HTTP request level, the audit logging code would fail due to a bytes/Unicode mismatch.
Instrumentation for the decr() method of umemcache client for Memcached was incorrectly calling the stats() method.

Python agent v2.50.0.39

Mon, 06 Apr 2015 00:00:00 +0000

Notes

This release of the Python agent adds support for Django 1.8.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

New Features

Support for Django 1.8.

Features Changed

The list of modules loaded by the application will no longer include version numbers. In certain cases, attempting to determine the version numbers of packages can potentially generate excessive CPU overhead, so it has been preemptively disabled to prevent any such occurrence.

Bugs Fixed

When using the psycopg2 Postgres database adapter, if the pscyopg2.extras.register_json() function was used, then instrumentation for the psycopg2 module would fail. Now, register_json() is instrumented correctly.
If a Django class based view was registered as the view handler in urls.py, the transaction was named after the class name, and not the method of the class based view which handled the request. Now, the transaction is named after the method.

Python agent v2.52.0.40

Thu, 11 Jun 2015 00:00:00 +0000

Notes

This release of the Python agent adds the ability to customize the hostname displayed in the APM UI, as well as updating the solrpy and pysolr instrumentation so that Solr metrics will now appear in the Databases tab in the UI.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

New Features

Customize hostname displayed in APM

A new configuration setting has been added: process_host.display_name. When set in the newrelic.ini configuration file, the display name will be used in the APM UI, in place of the hostname that the agent automatically captures. In addition, the display name can be set using the NEW_RELIC_PROCESS_HOST_DISPLAY_NAME environment variable.

Features Changed

Update solrpy and pysolr instrumention

Previously, solrpy and pysolr instrumentation reported metrics in the Solr namespace. Now, to align them with our recent changes to SQL and NoSQL instrumentation, solrpy and pysolr have been updated to report metrics in the Datastore namespace, which means that time spent in calls to Solr will be listed in both the main overview chart, as well as in the Databases tab in the UI.

Python agent v2.54.0.41

Wed, 29 Jul 2015 00:00:00 +0000

Notes

This release of the Python agent adds the ability to strip exception messages from error traces, in order to prevent the inadvertent capture of sensitive information.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

New Features

Allowing Exception Messages

Because an exception message can contain sensitive information, the agent now provides the ability to strip exception messages before sending error traces to APM. Exception messages will be stripped automatically in high-security mode.

For exception messages you know to be safe, you can add them to an allow list so that those messages are passed unaltered to APM. Two new configuration settings control this feature: strip_exception_messages.enabled and strip_exception_messages.whitelist.

Bug Fixes

capture_request_params API disabled for high-security mode

When operating in high-security mode, the agent should not capture query string parameters. However, prior to this release, it was possible to call newrelic.agent.capture_request_params(flag=True), even if the agent was in high-security mode, and the agent would capture and report query string parameters. Now, the capture_request_params API call does not override the capture_params setting when the agent is in high-security mode, so query parameters are not captured.

Python agent v2.58.0.43

Mon, 16 Nov 2015 00:00:00 +0000

Notes

This release of the Python agent reports error events to Insights and captures enhanced error data to support the new Advanced Error Analytics feature in APM.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

New Feature

Error Events

The Python agent now sends TransactionError events for Advanced Error Analytics, which power the new APM Errors functionality (currently in Beta). This allows users to create charts that facet and filter their error data by attributes, as well as explore their error events in Insights. For details, see the APM Errors documentation.

Changed Feature

Additional Attributes collected

The agent now collects additional attributes for web transactions:

HTTP request headers: Host and Accept
HTTP response header :Content-Length

Bug Fix

Improved unicode support for exception messages

Unicode exception messages will still be preserved, even if sys.setdefaultencoding() has been called to change the default encoding.

Python agent v2.56.0.42

Wed, 30 Sep 2015 00:00:00 +0000

Notes

This release of the Python agent adds much more flexibility around what attributes are sent to New Relic, and where they are displayed.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

New Feature

Flexible capturing of attributes

Attributes are key-value pairs that contain additional information to be added to an event or transaction. These key-value pairs can be viewed within transaction traces in New Relic APM, traced errors in New Relic APM, transaction events in Insights, and page views in Insights.

A number of new configuration settings have been introduced to allow you to customize exactly which attributes will be sent to each of these destinations.

For details, see Python agent attributes.

Deprecated Settings

Several configuration settings have been deprecated. The most commonly used of the deprecated settings are capture_params and ignored_params. It is still possible to achieve the same functionality as the old settings by using the new attributes.include and attributes.exclude settings. For examples, see Python agent attribute examples.

A complete list of deprecated settings can be found in deprecated configuration settings.

While the usage of deprecated settings is still supported, we recommend upgrading your configuration to use the new settings as soon as possible.

Changed Feature

Previously, it was possible to save a list, dict, or tuple as an attribute value that could be displayed in transaction and error traces. However, these same attributes could not be displayed in Insights events. Now, all attributes are handled in a consistent manner, which means that all attribute values must be one of the following types:

Python 2: str, unicode, int, long, float, bool
Python 3: str, bytes, int, float, bool

All values which are not one of these types are automatically converted by calling str(value).

Python agent v2.58.1.44

Tue, 17 Nov 2015 00:00:00 +0000

Notes

This release of the Python agent is a hotfix release to address a problem where the package failed to install under certain circumstances.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

Bug Fix

The README.rst file contained non-ASCII characters, which could result in a UnicodeDecodeError during installation. Those characters have been removed.

Python agent v2.60.0.46

Mon, 14 Dec 2015 00:00:00 +0000

Notes

This release of the Python agent enables the ability to add Custom Insights Events through a new record_custom_event() API.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

New Feature

Custom Events

Prior to this release, the Python agent had the capability to record two types of Insights events automatically: Transaction and TransactionError events. In addition, custom attributes could be added to those events. Now, with the addition of the record_custom_event() API, it is possible to define your own custom event types, enabling greater flexibility about what types of events you can view and query in Insights.

For details, see the Insights documentation on Inserting Custom Events.

Changed Feature

Attributes renamed

Two attributes have been renamed, in order to be consistent with the naming convention of other New Relic agents. The affected attributes are:

response.headers.contentLength (was response.contentLength)
response.headers.contentType (was response.contentType)

Python agent v2.58.2.45

Wed, 25 Nov 2015 00:00:00 +0000

Notes

This release of the Python agent is a hotfix release to address a problem where the agent could fail to validate the SSL certificate of the New Relic collector in some environments.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

Bug Fix

If the Python agent was used in an environment where the certifi package was installed, the Python agent would use the certifi CA certificates bundle to validate the certificate of the New Relic collector. However, the latest release of certifi (November 20, 2015) removed some older CA certificates with 1024-bit keys.

The SSL certificate for the New Relic collector is cross-signed with both a 1024-bit certificate and a 2048-bit certificate, but in some circumstances, the stronger root certificate was not used for validation. When the 1024-bit certificate was no longer included in the certifi bundle, SSL validation would fail. Affected customers would see warnings in their agent log stating "Data collector is not contactable" due to an SSLError.

To address this issue, the agent no longer uses the certifi CA certificates bundle, nor the certificates bundled with requests. Instead, it only uses the CA bundle included with the agent to validate the New Relic collector certificate.

Python agent v2.6.0.5

Sat, 02 Nov 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent contains support for web applications and worker processes using 'gearman' for background task execution. The agent also switches to using the 'json' package from the standard library instead of a separate 'simplejson' package. This should result in potential reductions in base level memory usage by the agent and a reduction of CPU overhead for some environments.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

New Features:

Instrumentation now provided for the gearman package. The support covers use of both the gearman client and worker interfaces. In the case of workers, each task executed by the worker will be recorded as a background task and be displayed as such in the New Relic UI.
The ignore_errors argument to newrelic.agent.record_exception() can now be a callable in addition to being able to pass a sequence. When it is a callable, the callback will be called with the three arguments exc, value and tb, being the same values as returned by sys.exc_info(). The callback should return True if the exception is to be ignored. False if the exception should never be ignored regardless of any other checks, and None if subsequent checks and inbuilt rules should determine if the exception should be ignored. A callback would normally return either True or None.

Bug fixes/Improvements:

The bundled 'simplejson' package has now been removed and is no longer used. This was previously used due to the requirement to support Python 2.5, for which support was removed in version 2.0.0 of the agent. Instead of simplejson, the 'json' package contained in the Python standard library is now used instead. This should see the base level memory usage of the agent drop as a result. Further, in environments where a C compiler was not available and the C extension modules could not be compiled, there should now be a minimal reduction in the CPU overhead when the agent is uploading data to our backend. This is because the optimised C extension in the json package will always be available as part of the Python standard library and will always be able to be used.
If a WSGI application was returning an iterable such as a generator, and an exception was raised when a specific part of the response content was yielded from the generator, the details of the exceptions were not being recorded.
In a multithreaded web application where deferred module imports were being performed in secondary threads, agent registration could fail the first time due to concurrent changes made by the secondary threads to sys.modules. Registration would succeed on a subsequent attempt. This bug was only occurring in Python 2 and was introduced in version 2.0.0 of the agent when Python 3 support was added.
Custom parameters which were explicitly supplied to newrelic.agent.record_exception() were being ignored and were not appearing in the error details page in the UI. Instead, only custom parameters added using newrelic.agent.add_custom_parameters() against the web transaction or background task itself were being shown. This bug was introduced in version 1.13.0 of the agent when support for cross application tracing was added.
The port number used in the URL for a web external call, was not being retained when the URL was added as a parameter against the web external node for transaction traces. The port would therefore not be displayed when drilling down into the details of a web external node in a transaction trace.
The newrelic-admin validate-config command will now work for enterprise high-security mode accounts, provided of course that no setting is otherwise specified in the agent configuration file which is in conflict with that mode. That is, features such as SSL would still need to be enabled by the ssl setting and the capture_params setting indicating whether URL query string parameters should be captured, also set to false.
When using CherryPy, in addition to the explicit exception type 'NotFound' being ignored as an error, raising of a 'HTTPError' exception where the status is 404 will also be ignored. Similarly, instances of the 'HTTPError' exception will be ignored as an error when they are for a HTTP error in the 30X range.

Python agent v2.64.0.48

Wed, 20 Apr 2016 00:00:00 +0000

Notes

This release of the Python agent is a bug fix release which improves our introductory support for instrumenting Tornado 4 applications. Full details about the status of our Tornado 4 support can be found on our Introductory Tornado 4 support page.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

New Feature

New attributes captured for Tornado 4 applications

The following attributes are now captured for requests made to Tornado 4 applications:
- request.headers.accept
- request.headers.host
- port

Bug Fixes

Potentially too many metrics created for tornado.httpclient function traces

The tornado.httpclient instrumentation for Tornado 4 applications could cause a "metric grouping issue" in the function traces it created, if it was used to make requests to a large number of unique URLs. To address this issue, the URL is no longer included in the name of the function trace.
Transactions in Tornado 4 applications could be created with invalid agent settings

In the prior release, if a transaction started before the agent had completed registration with the collector, the transaction could have invalid settings, which would result in various errors in the agent log, including an AttributeError when an external call was made during the transaction. These errors only happened at application startup until registration was complete. With this release, transactions cannot start with invalid settings.
The httplib2 instrumentation did not process the cross application tracing headers in the response

Failing to process the response headers resulted in the inability to link to cross application tracing details in the Transaction Trace Details view, as well as missing ExternalTransaction and ExternalApp metrics. Now, the httplib2 instrumentation in the agent processes the cross application tracing headers correctly.

Known Tornado 4 Limitations Addressed

Explain plans for queries made with psycopg2's "async mode" are disabled automatically

Currently, the Python agent does not support explain plans for queries made in psycopg2's "async mode." In the prior release, it was necessary to add the configuration setting transaction_tracer.explain_enabled = false to disable explain plans, or else errors would occur during data harvest, potentially causing loss of data. With this release, the agent disables explain plans automatically when async mode is detected.
Added support for synthetics transaction traces

Tornado 4 applications will now recognize incoming requests from synthetics and generate transaction traces for Synthetic requests.

Status of Tornado 4 Support

A current list of known limitations can be found on our Introductory Tornado 4 support page. No new known limitations have been added since our introductory release (v2.62.0.47). In the next few releases, we plan to continue addressing these issues.

Python agent v2.62.0.47

Wed, 30 Mar 2016 00:00:00 +0000

Notes

This release of the Python agent adds introductory support for instrumenting Tornado 4 applications.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

New Feature

Introductory Support for Tornado 4. (See below for details.)

Bug Fix

Django Template Tags for Browser Monitoring Fixed for Django 1.9

For manual insertion of the browser monitoring javascript for page load timing, the Python agent offers two Django template tags: newrelic_browser_timing_header and newrelic_browser_timing_footer.

Starting in Django version 1.9, the output of simple_tag is now escaped, which results in the browser monitoring javascript being included as escaped text in the HTML output. To fix this issue, the agent now uses django.utils.safestring:mark_safe() to prevent automatic escaping for these two template tags.

Introductory Support for Tornado 4

New Relic is pleased to announce introductory support for Tornado 4. While not all features are supported at this point, providing it at an early stage allows interested customers to preview our Tornado 4 support, and provide feedback on what works well and what doesn't.

We strongly advise running the introductory Tornado 4 instrumentation in a testing or staging environment before considering using it in a production environment.

For detailed information about the introductory Tornado 4 support, including Supported Features, Design Decisions, and Known Limitations, see Introductory Tornado 4 support.

Status of Tornado 4 Support

The following is a list of known limitations for our Tornado 4 support as it exists in the current version of the agent. In the next few releases, we plan to address these issues.

If you use psycopg2 in aynchronous mode, you must disable explain plans in the Python agent, or else the agent will throw an error when it attempts to run an explain plan query. Add this setting to your newrelic.ini configuration file:
```
transaction_tracer.explain_enabled = false
```
Metric names should be more consistent. For a method of a class, the metric name should contain both the name of the class and the method, but sometimes, the metric name will be missing the class name.
The nesting of segments in a Transaction Trace should be improved. Right now, transaction traces give a good indication of the order that callbacks run on the IOLoop, but they do not group together callbacks that belong to the same coroutine, nor do they show how callbacks relate to each other.
Transaction Traces mislabel time spent in "Application code". Because the Tornado 4 instrumentation traces all callbacks that run on the IOLoop, nearly everything that happens in a transaction is recorded. Very little is uninstrumented "Application code". When you see "Application code" time in a transaction trace, that usually means that the IOLoop was either busy running callbacks belonging to another transaction, or was waiting and not doing any work. This will be made clearer in a future release.
In the current version of the agent, the Total Time for a transaction will always equal the duration of the transaction. In future versions, we may begin measuring the time spent waiting for asynchronous External Traces and Datastore Traces to return results, which will increase the Total Time for a transaction, making it possible to have a Total Time greater than the duration of the transaction.
When using tornado.httpclient, no Cross Application Tracing headers are added to the outgoing requests. (This is true for both HTTPClient and AsyncHTTPClient.) That means that the application that the httpclient connects to will not show up in any of the following: trace maps, transaction maps, and service maps.
Asynchronous External Traces only trace the initial HTTP connection. They do not trace the time for the response to come back.
If you monitor your Tornado 4 application with synthetic monitoring, the Python agent will not capture transaction traces for synthetic checks, so you will be unable to connect your synthetic results to APM transaction traces.
Measuring thread utilization is disabled for Tornado applications.
Exceptions thrown in RequestHandler.initialize() are not recorded.
Use of Tornado's built-in multi-process mode to start multiple processes and have them all share the same port is untested and unsupported.
Use of tornado.wsgi.WSGIAdapter and tornado.wsgi.WSGIContainer is untested and unsupported.
Use of tornado.platform.asyncio to bridge between asyncio and Tornado IOLoop is untested and unsupported. Currently, the agent only supports the use of the tornado.ioloop.IOLoop.
Use of the async and await keywords is untested and unsupported.
Integration with Twisted is untested and unsupported.

Python agent v2.66.0.49

Thu, 26 May 2016 00:00:00 +0000

Notes

This release of the Python agent is a bug fix release that addresses several outstanding issues. In addition, the agent's instrumentation for the Pyramid web framework was updated to handle changes introduced in version 1.7 of Pyramid.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

For a list of known issues with the Python agent, see Status of the Python agent.

New Feature

Support for Pyramid 1.7

In version 1.7 of the Pyramid web framework, the ViewDeriver class was removed and replaced with a custom view pipeline, composed with view derivers. This required a change to where the agent applied it's instrumentation, since we were previously instrumenting the ViewDeriver class.

Bug Fixes

Gevent and Python 3.4+

When running the agent with gevent in Python 3.4+, the agent would throw an AttributeError when accessing the _sleep attribute in the threading module, which was removed in Python 3.4. The agent now handles this properly.
Possible missing application exceptions in APM Error Analytics

Using the record_exception() API, it is possible to record an exception against the application, but outside of a transaction. If there was a time window in which no transaction exceptions were recorded, but only application exceptions were recorded, then no exceptions would be displayed when viewing that time window in APM Error Analytics. With this release, application exceptions show up as expected, whether or not transaction exceptions were also recorded.
CherryPyWSGIServer and keyword arguments

Previously, the agent would fail to instrument CherryPyWSGIServer correctly when it was initialized using keyword arguments. That is now handled correctly.
Missing attributes in Transaction Events

In version 2.60.0.46 of the agent, two response header attributes were renamed, but they were not added to Transaction Events as they should have been.
- response.headers.contentLength
- response.headers.contentType
These attributes are now included in Transaction Events.

Changed Feature

Capture port for all HTTP requests to External Services

Prior to this release, the agent would capture the port for HTTP requests to external services for only some of the HTTP libraries that the agent instruments. Notably, the port was missing when using these libraries directly: httplib, httplib2, and urllib3. The agent now captures the port for these libraries.

Python agent v2.68.0.50

Tue, 19 Jul 2016 00:00:00 +0000

Notes

This release of the Python agent is a bug fix release that addresses several recently reported issues.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

Bug Fixes

WebSocket requests could cause application errors

When an application is using gevent-websocket to serve a mixture of WSGI and WebSocket endpoints, it is possible for WebSocket requests to interfere with the instrumentation of non-WebSocket requests, and cause application errors. While a fix for this has been added to the 'gevent-websocket` main branch, that fix has not been released to PyPI yet. To address the problem now, the Python agent explicitly ignores WebSocket requests.
Disabling browser monitoring inadvertently disabled other features

Disabling browser monitoring had the unintended effect of disabling certain other Response-related features of the agent. Specifically, the response.status attribute was not recorded, and the Cross Application Tracing headers were not added to the HTTP headers of the outgoing response. With this release, those features now work when using the configuration setting of browser.monitoring.enabled = False.
Calling a Celery task within another task could cause a RuntimeError

The Python agent would throw a RuntimeError('transaction already active') when instrumenting a Celery task that performed the following combination of actions:
1. Utilized the agent API to end the transaction early (end_of_transaction), or to ignore the transaction altogether (ignore_transaction).
2. After ending or ignoring the transaction, called another Celery task that would run synchronously.
This scenario, which most commonly occurs when taking advantage of Celery Workflows to compose multiple tasks together, will no longer result in a RuntimeError.

Python agent v2.70.0.51

Tue, 06 Sep 2016 00:00:00 +0000

Notes

This release of the Python agent adds support for the improved Django middleware introduced in Django v1.10, and also adds instrumentation for the boto3 and awscli packages.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

New Features

Django 1.10 Middleware Support

As described in Django Enhancement Proposal 5 and in the Django v1.10 middleware documentation, Django introduced a new style of middleware in version 1.10. Previously, Django allowed you to define certain methods on middleware classes: process_request() methods would run before the view handler was invoked, and process_response() methods would run after the response was generated. Accordingly, the Python agent would instrument these as separate, self-contained methods, and in the Transaction Trace Details view, they would be displayed at the same level as the view handler in the segments hierarchy.

With the improved version in Django v1.10, the middleware classes form a "chain", and each middleware calls the next middleware, until it reaches the end of the chain and calls the actual view. This means that new-style middleware acts as a wrapper, and each one is nested inside the previous one. As a result, in the Transaction Trace Details view, each middleware will be nested inside the previous one, and the actual view handler will be displayed nested inside the innermost middleware class. Furthermore, the duration of each middleware segment will include the duration of the middleware nested inside it.

Because Django v1.10 is backwards-compatible with the old-style middleware, the agent also supports instrumenting old-style middleware in Django v1.10
Boto3 and AWS CLI Support

With this release, API calls to Amazon Web Services endpoints made with the boto3 and awscli packages will be recorded as External Traces and will be visible in the External Services tab in APM. This is achieved by instrumenting the botocore library, which both boto3 and awscli utilize.

Bug Fixes

Proxy Scheme Output of network-config Command

Prior to this release, the newrelic-admin network-config command would output the incorrect proxy scheme. That is now fixed.
Debug Console Works with Python 3

The newrelic-admin debug-console is now compatible with Python 3.

Python agent v2.72.0.52

Tue, 18 Oct 2016 00:00:00 +0000

Notes

This release of the Python agent adds support for reporting datastore instance information for the psycopg2 Postgresql driver.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

New Feature

Datastore instance information for psycopg2

For queries made with the psycopg2 Postgresql driver, the Python agent will collect the host and port of the database server, as well as the database name. This data will be displayed in transaction traces and in slow query traces in APM.

Python agent v2.72.1.53

Tue, 25 Oct 2016 00:00:00 +0000

Notes

This release of the Python agent is a hotfix release to address a problem introduced in our last release (v2.72.0.52) where users of the psycopg2 Postgresql database adapter could see extra Datastore entries in the Breakdown Table on the Transactions page in APM.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

Bug Fix

Remove extra Datastore segments from the Transactions Breakdown Table

Due to the extra Datastore segments in the Breakdown Table on the Transactions page in APM, the "% Time" column would add up to greater than 100%. This problem has now been fixed. Users of psycopg2 who are using v2.72.0.52 of the Python agent are encouraged to upgrade to this latest version.

Python agent v2.76.0.55

Wed, 14 Dec 2016 00:00:00 +0000

Notes

This release of the Python agent adds support for reporting datastore instance information for the python-memcached library. It also addresses a couple of Python 3 issues related to naming metrics and transactions.

Over the past few releases, support has been added to the agent for collecting datastore instance information for a number of drivers. See a complete list of supported packages.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Datastore instance information for python-memcached

For most memcached operations made using the python-memcached package, the Python agent will collect the host and port of the memcached server, as well as the memcached database index number. This data will be displayed in transaction traces and in slow query traces in APM.

Supported operations include: add, append, cas, decr, delete, get, gets, incr, prepend, replace, set.

Currently, the Python agent does not collect instance information for operations that interact with multiple memcached instances. These include: delete_multi, flush_all, get_multi, get_slabs, get_stats, set_multi.

Bug Fixes

Names for subclass methods in Python 3

Previously, when using Python 3, if a method was defined on a base class, but was called as a method on an instance of a subclass, the agent would generate a metric name or transaction name for that method using the base class. It would also use the module name of the base class in the metric or transaction name.

With this release, the metric name or transaction name will use the class name of the subclass, as well as the module name of the subclass. This is consistent with how the naming works for Python 2.
Names for Flask pluggable views in Python 3

When monitoring Python 3 Flask applications, the agent would create metric and transaction names for Flask pluggable (or, class-based) views using the name of the View.as_view() classmethod, making it impossible to distinguish between different views in APM. Now, the metric and transaction name uses the name that is passed into View.as_view().

For example, a view defined as view_func=ShowUsersView.as_view('show_users') would use show_users as the view name. This is consistent with how the naming works for Python 2.
Redis client with custom connection pool

If a custom connection pool was used with the redis client, the agent could throw an AttributeError when attempting to gather datastore instance information. One library known to define a custom connection pool that encountered this issue is Redis Blaster. With this release, the agent will no longer throw an error for custom connection pools. In addition, the agent will now be able to gather datastore instance information for some operations, even when using a custom connection pool.
Developer Mode error message during "fake" harvest

When using the configuration setting of developer_mode = True, the agent does not transmit any data to New Relic. Instead, it performs a "fake harvest". In some cases, it was possible for the agent to log an AssertionError during the "fake harvest", but this issue has now been fixed.

Python agent v2.74.0.54

Mon, 14 Nov 2016 00:00:00 +0000

Notes

This release of the Python agent adds support for reporting datastore instance information for both the redis and MySQLdb drivers.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Datastore instance information for redis

For redis operations made using the redis-py package, the Python agent will collect the host and port of the redis server, as well as the redis database index number. This data will be displayed in transaction traces and in slow query traces in APM.
Datastore instance information for MySQLdb

For queries made with the MySQLdb driver, the Python agent will collect the host and port of the database server, as well as the database name. This data will be displayed in transaction traces and in slow query traces in APM.

Python agent v2.78.0.57

Wed, 04 Jan 2017 00:00:00 +0000

Notes

This release of the Python agent adds support for reporting datastore instance information for the elasticsearch library.

Over the past few releases, support has been added to the agent for collecting datastore instance information for a number of drivers. See a complete list of supported packages.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Feature

Datastore instance information for elasticsearch

For operations made using the official Elasticsearch client, the Python agent will collect the host and port of the elasticsearch server. This data will be displayed in transaction traces and in slow query traces in APM.

Bug Fix

Cornice 2.3.0 TypeError

When using the latest version of Cornice,the Python agent would raise a TypeError exception due to not handling the changed signature of cornice.Service.decorate_view(). Earlier versions of Cornice were not affected, and with this release, the Python agent no longer raises an error for version 2.3.0.

Python agent v2.80.0.60

Thu, 23 Feb 2017 00:00:00 +0000

Notes

This release of the Python agent enhances our introductory support for Tornado 4, most notably by adding support for tornado.curl_httpclient.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Tornado 4 curl_httpclient support

Previously, the agent's Tornado 4 instrumentation only supported the default tornado.simple_httpclient. With this release, support has been added for tornado.curl_httpclient as well.
Tornado 4 ZeroMQ IOLoop support

Using ZMQIOLoop in place of the default Tornado IOLoop is now supported for Tornado 4 applications.

Improved Feature

Improved transaction names for Django REST Framework

When using the Python agent with Django REST Framework and Python 3, function-based views wrapped with the rest_framework.decorators.api_view decorator would result in transactions with names based on the decorator (WrappedAPIView.handler) rather than names based on the original view function. (This did not affect applications running with Python 2.)

With this release, the transaction names for these wrapped views are now based on the name of the original view function in both Python 2 and Python 3.

Bug Fix

End transactions correctly with Tornado 4 @asynchronous decorator

When the agent records a transaction for a Tornado 4 RequestHandler method that is decorated with the @tornado.web.asynchronous decorator, the transaction should remain open until RequestHandler.finish() is called. Prior to this release, there were some circumstances where the agent closed the transaction prematurely, resulting in transaction durations that were too short. This has now been fixed.

Python agent v2.80.1.61

Mon, 27 Feb 2017 00:00:00 +0000

Notes

This release of the Python agent is a hotfix release to address a problem with the Tornado 4 instrumentation for curl_httpclient introduced in our last release (v2.80.0.60). Under the circumstances described below, calling CurlAsyncHTTPClient.fetch_impl() could result in an agent error.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

Bug Fix

Fix CurlAsyncHTTPClient.fetch_impl() instrumentation

If fetch_impl() was called by passing the request argument positionally, but passing callback as a keyword argument, then the agent would throw an error. In practice, this only affected customers who implemented a custom version of fetch_impl(), but for those affected customers, this is now fixed.

Python agent v2.82.0.62

Wed, 15 Mar 2017 00:00:00 +0000

Notes

This release of the Python agent improves our introductory support for Tornado 4 applications by adding Cross Application Tracing for web transactions that are sent to a Tornado 4 application.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Feature

Tornado 4 applications will now appear in Service Maps

Tornado 4 Cross Application Tracing is now supported for inbound web transactions. In addition to Service Maps, the calling application's APM will now have links to the Tornado 4 application it called in the External Services tab and in Transaction Traces.

Bug Fixes

Record exceptions outside of view handlers in Django 1.10

Unhandled exceptions that occurred outside of a view handler in Django 1.10 were not reported. In addition to middleware exceptions, these unhandled exceptions can be generated when a view handler returns a TemplateResponse and rendering that template would result in an exception.
Consistent WSGI/Application and WSGI/Response segments

Prior to this release, the agent would group segments under WSGI/Application and WSGI/Response differently, depending on whether or not browser monitoring was enabled. This has now been made consistent.
Improved New Relic WSGI middleware behavior

The New Relic agent is now resilient when called by non-conforming middleware. Transactions will continue to be reported normally when the New Relic agent is called by WSGI middleware that does not call the close() method as described in the PEP 333 specification.

Python agent v2.8.0.7

Fri, 13 Dec 2013 00:00:00 +0000

The end-of-life date for this agent version is July 29, 2019. To update to the latest agent version, see Update the agent. For more information, see End-of-life policy.

Notes

This release of the Python agent marks the official introduction of support for pypy. Instrumentation has also been updated to address issues arising from the release of Celery 3.1.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from our download site.

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

New Features:

The agent has worked with and has already been used by customers with pypy for some time, but we have not officially acknowledged that we support pypy. We have now integrated pypy into our test procedures and now officially support this implementation of the Python language.

Bug fixes/Improvements:

Instrumentation for Celery has been updated to accommodate changes in Celery 3.1. The changes in Celery 3.1 resulted in no metrics being reported in prior versions of the agent.
When collecting data on external web service calls, the agent now drops port 80/443 from the name of the host when used with the standard http/https protocol schemes. This ensures that a URL with or without the ports are seen as the same service in the external web services page in the UI.
When using newrelic.agent.initialize() explicitly, if no arguments are provided, the values for the config file and environment arguments will now be read from the NEW_RELIC_CONFIG_FILE and NEW_RELIC_ENVIRONMENT arguments if specified.
Flask instrumentation was not correctly mapping URLs related to a HTTP 404 response to a known framework or application handler function. Instead the web transaction was named after the URL, which could result in metric grouping issues if an application was hit with a large number of URLs which couldn't be mapped by the application. Such requests will now be mapped to flask.app:Flask.handle_http_exception.
Pyramid instrumentation should no longer report as errors instances of exceptions derived from HTTPRedirection, raised to generate a HTTP redirect response.
Improvements to the newrelic-admin wrapper script and agent bootstrapping procedure to better deal with a local sitecustomize.py file. Changes will also better handle the case where the newrelic-admin wrapper script was used around a Python script using a different Python installation than that which the newrelic package was installed in, avoiding possible errors when the wrapped script was run, due to the mismatch.

Python agent v2.82.1.63

Mon, 17 Apr 2017 00:00:00 +0000

Notes

This release of the Python agent includes a bug fix for our introductory support for Tornado 4 applications.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Ending Tornado 4 transactions inside of a traced function results in an internal agent error

Ending a Tornado 4 web transaction within a traced function previously resulted in the generation of an agent traceback. The agent now completes tracing the function before ending the transaction, resulting in the correct reporting of these transactions to New Relic.

Python agent v2.84.0.64

Tue, 25 Apr 2017 00:00:00 +0000

Notes

This release of the Python agent includes bug fixes and improvements to the precision of the duration data recorded for transaction traces.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Improved Feature

Transaction trace precision

This release improves the precision of transaction traces. Duration of functions in a transaction trace are now recorded at sub-millisecond precision.

Bug Fixes

Custom classmethod traces may incorrectly return the parent class

Wrapping classmethods in classes that are subclassed could cause the subclassed classmethod to be improperly bound to the parent class. This would result in the classmethod returning an instance of the parent class when the method was called on a child class.
Handle incomplete Tornado coroutine traces

Tracing a Tornado coroutine that never completed and was later garbage collected, could result in an application hang. This has been fixed.

Python agent v2.86.0.65

Wed, 03 May 2017 00:00:00 +0000

Notes

This release of the Python agent includes improvements to our introductory support for Tornado 4 applications as well as bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Feature

Tornado 4 Outbound Cross Application Tracing

Tornado 4 Cross Application Tracing is now supported for outbound web transactions. In addition to Service Maps, Tornado 4 transaction traces will now contain links to the application it called. With this update, Cross Application Tracing is now fully supported for Tornado 4 applications.

Bug Fixes

Django 1.10+ browser monitoring with new-style gzip middleware

Browser monitoring was not automatically inserted when using new style Django 1.10+ gzip middleware. Browser monitoring code is now inserted as expected.
Using motor versions 1.X generated instrumentation errors

Motor 1.0 removed the MotorReplicaSetClient class which resulted in the New Relic Python Agent generating an instrumentation error when attempting to access that class. The instrumentation has been fixed.

Python agent v2.86.1.66

Wed, 17 May 2017 00:00:00 +0000

Notes

This release has been superseded. Please use version 2.86.2.68 or higher.

This release of the Python agent includes various bug fixes as described below.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Handle exceptions generated by Tornado 4 AsyncHTTPClient during fetch

Exceptions generated by a call to the Tornado 4 AsyncHTTPClient resulted in an agent instrumentation error. Exceptions generated by AsyncHTTPClient are now recorded and properly handled.
Using gevent/eventlet on Python 3.6 resulted in a RecursionError

Python 3.6 introduced a change to the ssl library. This change can result in a recursion error when the New Relic agent imports ssl prior to eventlet/gevent patching the ssl library (as is the case with use of the newrelic-admin script). This recursion error has been mitigated when using newrelic-admin to start applications.

Python agent v2.86.3.70

Fri, 26 May 2017 00:00:00 +0000

Notes

This release of the Python agent includes various bug fixes as described below.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Handle exceptions generated by Tornado 4 AsyncHTTPClient during fetch

Exceptions generated by a call to the AsyncHTTPClient resulted in an agent instrumentation error. Exceptions generated by AsyncHTTPClient are now recorded and properly handled.
Using gevent/eventlet on Python 3.6 resulted in a RecursionError

Python 3.6 introduced a change to the ssl library. This change can result in a recursion error when the New Relic agent imports ssl prior to eventlet/gevent patching the ssl library (as is the case with use of the newrelic-admin script). This recursion error has been fully mitigated.

Python agent v2.86.2.68

Tue, 23 May 2017 00:00:00 +0000

Notes

This release is the same as 2.86.0.65 except it has been re-published to pypi due to an issue with 2.86.1.66.

Python agent v2.90.0.75

Mon, 31 Jul 2017 00:00:00 +0000

Notes

This release of the Python agent includes bug fixes and improvements to the builtin pika instrumentation.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Improved Feature

Naming of Pika Message Transactions

This release improves the naming of message transactions . Message consumer transactions are now split based on the name of the consume callback.
Improved metadata collection for cloud providers

The agent now collects additional metadata when running in AWS, GCP, Azure, and PCF. This information is used to provide an enhanced experience when the agent is deployed on those platforms.

Bug Fixes

CherryPy WSGI Server automatic instrumentation

This release fixes a bug where cherrypy.wsgiserver.CherryPyWSGIServer was not being instrumented. This bugfix impacts CherryPy versions v6.1.0 to v8.9.1.

Python agent v2.88.0.72

Thu, 06 Jul 2017 00:00:00 +0000

Notes

This release of the Python agent adds built-in instrumentation for the pika RabbitMQ library, a message broker API which can be used to add custom instrumentation for additional message brokers, and various bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Pika Instrumentation

The RabbitMQ pika library is now automatically instrumented. The agent will report data for messages sent and received by an application. Data on messages is available in both APM and Insights. Applications connected through a RabbitMQ exchange will now also be visible on Service Maps as part of Cross Application Tracing.
Message Broker API

A Message Broker API is now available for use in custom instrumentation. The Message Broker API will send data to APM and Insights (through message.routingKey and message.queueName attributes) for message broker related operations.
Tornado 4.5 Support

The Python Agent's out-of-the-box Tornado 4 instrumentation now supports Tornado version 4.5.
Tornado AsyncIO Loop

In addition to the Tornado PollIOLoop, the AsyncIO loop is now supported as part of our Tornado instrumentation. When Tornado is configured to use the AsyncIO loop, data will now be sent to New Relic. Note that AsyncIO is not yet generally supported.

Bug Fixes

SQL comments beginning with a "--" resulted in an improperly parsed query

When executing SQL queries with comments that used the "--" comment syntax, the database operation and table was not properly parsed resulting in queries being absent from the Databases tab. Queries with "--" comments should now show up in the Database tab.
AttributeError generated when using Tornado 4 HTTPRequest objects in an external web call

When using the Tornado 4 HTTPRequest object as an argument to HTTPClient.fetch, it was possible to generate an AttributeError. The web call now completes as expected.
Slow network connections may result in lost data

When, due to a slow network, a 408 error is returned from New Relic data was not retransmitted. Data is now retransmitted when a 408 is received.

Python agent v2.94.0.79

Tue, 19 Sep 2017 00:00:00 +0000

Notes

This release of the Python agent adds instrumentation for aiohttp client.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Add instrumentation for aiohttp client

Outbound HTTP requests through the aiohttp library are now recorded. aiohttp Cross Application Tracing is now supported for outbound requests. In addition to Service Maps, applications accessed through the aiohttp client will now appear in transaction traces.

Bug Fixes

Fix crash when using psycopg2 v2.7 composable queries

The psycopg2 library introduced a module to generate SQL dynamically (psycopg2.sql) in version 2.7. Passing a Composable type object (psycopg2.sql.Composable) to execute or executemany resulted in an application crash. The agent now correctly handles psycopg2 Composable objects.

Python agent v2.96.0.80

Mon, 16 Oct 2017 00:00:00 +0000

Notes

This release of the Python agent adds instrumentation for aiohttp framework, adds support for displaying Heroku dyno names, and various bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Add instrumentation for aiohttp framework

Data is now automatically collected for applications using the aiohttp framework. Data for aiohttp applications will appear in both APM and Insights. Additionally, cross application tracing is supported for incoming requests for aiohttp applications. In addition to service maps, aiohttp applications will now show the calling application in transaction traces.
Add support for displaying Heroku dyno names

Heroku-friendly logic is now applied to how dyno names are displayed. This includes being able to collapse dyno hostnames based on prefix.

Bug Fixes

Fix crash for gunicorn gaiohttp driver

Using gunicorn's gaiohttp worker with New Relic Browser monitoring enabled may have resulted in an application crash. This crash has been fixed and the gaiohttp worker is now fully supported with the New Relic Python Agent.
Fix crash for pika versions 0.9.x and earlier

Using the agent with pika versions 0.9.x and earlier could have resulted in an application crash. This issue has now been fixed.

Python agent v2.98.0.81

Thu, 30 Nov 2017 00:00:00 +0000

Notes

This release of the Python agent adds improvements to django instrumentation, improvements to django rest framework instrumentation, and various bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Improved Features

Enabled reporting of handled exceptions in Django REST Framework

Exceptions handled by django rest framework are now reported if the resulting response code is not ignored (see ignore_status_codes for details).
Add support for the error_collector.ignore_status_codes setting in Django

Ignoring exceptions in Django was previously limited to the error_collector.ignore_errors configuration option. Ignoring exceptions by response status code is now supported for Django through the use of the error_collector.ignore_status_codes configuration option.

Bug Fixes

Servicing aiohttp websocket requests results in an application crash

Servicing a websocket request in an aiohttp application may have resulted in an application crash when using the New Relic python agent. The application will now operate as expected when handling a websocket request.
Ignore incomplete aiohttp transactions

In aiohttp, connections can be terminated prior to the HTTP response being generated and sent. In those cases, the request handler may be cancelled. These transactions are no longer reported.
Fix HTTP status reporting for Tornado transactions

HTTP status was not properly added to Tornado transaction events and transaction traces. HTTP status is now automatically added to Tornado transaction events in Insights and transaction traces in APM.
Fix reporting of concurrent external requests in Tornado

External requests that execute in parallel in a tornado application may not have been recorded. This issue has been addressed.

Python agent v2.88.1.73

Wed, 12 Jul 2017 00:00:00 +0000

Notes

This release of the Python agent includes bug fixes for the pika RabbitMQ library instrumentation.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Using pika to make RPC-style calls from Tornado could result in an application crash

When making a remote procedure call from a tornado web application using the pika RabbitMQ library's Tornado connection, it is possible for the tornado web application to crash. Pika Tornado connections no longer result in an application crash.
AttributeError generated from an unregistered application starting a MessageTransaction

Applications which consume message transactions and do not call register_application can raise an AttributeError resulting in an application crash. This issue has now been fixed.

Python agent v2.92.0.78

Wed, 06 Sep 2017 00:00:00 +0000

Notes

This release of the Python agent adds support for monitoring of outbound gRPC requests and adds an API for cross application tracing of custom non-HTTP transports. For details on APIs for cross application tracing see the cross application tracing document.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Add API for cross application tracing of non-HTTP external services 

A new API is now exposed for implementing cross application tracing in custom instrumentation of non-HTTP transport libraries. For usage of this API see the cross application tracing document. 
Add instrumentation for gRPC client calls 

Outbound gRPC requests will now show up in APM under the External Services tab and in transaction traces.

Bug Fixes

Fixes erroneous recording of TastyPie NotFound exceptions

 When a TastyPie API view raised a NotFound exception resulting in a 404 response, the agent may have erroneously recorded the exception. This has now been fixed.

Python agent v3.0.0.89

Wed, 14 Mar 2018 00:00:00 +0000

Notes

This release of the Python agent removes previously deprecated APIs, makes SSL communication with New Relic mandatory, and updates support for aiohttp middleware.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Deprecations

Removed previously deprecated APIs

The following APIs have been removed:
- transaction (use current_transaction)
- name_transaction (use set_transaction_name)
- Application.record_metric (use Application.record_custom_metric)
- Application.record_metrics (use Application.record_custom_metrics)
- Transaction.notice_error (use Transaction.record_exception)
- Transaction.record_metric (use Transaction.record_custom_metric)
- Transaction.name_transaction (use Transaction.set_transaction_name)
Deprecate Transaction.add_user_attribute

Transaction.add_user_attribute has been deprecated in favor of Transaction.add_custom_parameter. Transaction.add_user_attribute will be removed in a future release.
Deprecate Transaction.add_user_attributes

Transaction.add_user_attributes has been deprecated in favor of Transaction.add_custom_parameters. Transaction.add_user_attributes will be removed in a future release.
Deprecate wrap_callable

wrap_callable has been deprecated in favor of FunctionWrapper. wrap_callable will be removed in a future release.
Remove data-source admin command

The platform API (used by newrelic-admin data-source) has been removed. Please use data sources in place of the platform API.

SSL

SSL connections to New Relic are now mandatory

Prior to this version, using an SSL connection to New Relic was the default behavior. SSL connections are now enforced (not overrideable).

AIOHTTP Updates

Add automatic tracing of AIOHTTP 3 middleware

In addition to the old-style middleware previously supported, the AIOHTTP 3 style middleware is now automatically traced as part of the AIOHTTP instrumentation package.

Python agent v3.2.0.91

Wed, 04 Apr 2018 00:00:00 +0000

Notes

This release of the Python agent adds the request.uri attribute on transaction events in insights, adds built-in cheroot instrumentation, adds support for recording flask-restful/flask-restplus exceptions, and contains bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Improved Features

Add request.uri attribute to transaction and error events

The Python agent will now report request.uri as an attribute on transaction events and error events. To disable this feature, add request.uri to the attributes.exclude list in the newrelic.ini configuration file.
Record Flask RESTful and Flask RestPlus exceptions

Since Flask RESTful and Flask RestPlus handle all errors that are raised in their handlers, these errors were not being captured by the normal Flask instrumentation in the Python agent. Exception handling has now been added for these two components.
Add instrumentation hooks for the Cheroot WSGI server

Any customers using Cheroot with an unsupported application framework will now see data reported in New Relic APM.

Bug Fixes

Fix CherryPy ignore by status code for exceptions using reason phrases

CherryPy accepts string values for HTTPError status (reason phrases). When creating HTTPError exceptions in this way, responses were not properly ignored by status code. Responses generated by HTTPError exceptions using reason phrases are now properly ignored.
Using send_file with Flask Compress middleware may have caused an application crash

When using browser monitoring auto instrumentation on an application using Flask Compress, the use of the Flask send_file helper to send html files resulted in an application crash. This issue has now been resolved.
Fix incorrect parenting for traces of coroutines scheduled with asyncio gather/ensure_future

Coroutines scheduled with asyncio gather/ensure_future may have been reported as being a child of the wrong function. This issue has now been corrected.

Python agent v3.2.1.93

Wed, 16 May 2018 00:00:00 +0000

Notes

This release of the Python agent contains various bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Do not run explain plans for psycopg2 connections using the async_ kwarg

As "async" is now a keyword in Python 3.7, psycopg2 now allows "async_" as an alias for its "async" kwarg for psycopg2.connect as of psycopg2 v2.7.4. Previously, explain plans were attempted for these connections and a traceback would be seen in the logs. This has now been fixed.
Fix traceback when using callbacks as partials in pika consumers

When passing a callback that is a functools partial to pika channel consumers, a traceback occurred in some instances. This issue has now been fixed.
cx_Oracle database calls that use SessionPool objects were not recorded

When using the cx_Oracle SessionPool interace, database transactions made through the acquired pool connection may not have been reported. Database transactions that using connections generated by SessionPool are now reported as expected.
SQL targets for call statements may contain a period

For a SQL command like CALL foo.bar(:baz), APM would show metrics under the target name foo instead of the full name foo.bar. This has been fixed.

Python agent v3.2.2.94

Mon, 11 Jun 2018 00:00:00 +0000

Notes

This release of the Python agent contains various bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Improved handling of celery max-tasks-per-child

Data recorded by the Python Agent may not have been reported when celery was operated with the max-tasks-per-child setting. All data is now reported independent of the max tasks per child setting.
Improve support for PyMongo v3.x

PyMongo v3 added many new methods on the pymongo.Collection object that did not exist in v2. These methods have now been instrumented. Calls to these methods will now appear in APM.
Scheduling tasks that run after a transaction ends causes an error

Coroutines scheduled to execute after a transaction ends using create_task or ensure_future may have caused the runtime instrumentation error and subsequent crash:
```
The transaction already completed meaning a child called complete trace after the trace had been finalized.
```
Coroutines that execute beyond the end of a transaction will no longer cause an error.

Python agent v4.10.0.112

Thu, 10 Jan 2019 00:00:00 +0000

Notes

This release of the Python agent adds support for excluding attributes from span events and transaction trace segments, adds a new api called add_custom_parameters, and includes various bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Features

Add ability to exclude attributes from span events and transaction trace segments

This release adds support to exclude attributes (such as http.url) from span events (via the span_events.include/span_events.exclude options) and from transaction segments (via the transaction_segments.include/transaction_segments.exclude option).

As with other attribute destinations, these new options will inherit values from the top-level attributes.include/attributes.exclude settings. See the documentation for more information.
Add public add_custom_parameters API

The method add_custom_parameters on Transaction is now exposed through newrelic.agent.add_custom_parameters

Bug Fixes

Transaction counts were not reported for aiohttp's built-in error pages

When a built-in error route was reached in aiohttp (such as a 404 due to a missing route), transactions were not recorded. As a result, the transaction counts may have been artificially low. aiohttp system route traffic will now be reported.
aiohttp cross application tracing linking to non-Python applications may have been omitted if using multidict<3.0

For aiohttp users using multidict versions less than 3.0, cross application tracing HTTP headers may have been generated in a way that was incompatible with non-Python applications. Headers are now generated in a format compatible with all New Relic agents.
aiohttp 3.5.x versions generated agent instrumentation errors

The agent previously failed to instrument aiohttp applications running versions 3.5.0 and greater. The agent now supports aiohttp versions up to 3.5.1.

Python agent v3.4.0.95

Thu, 12 Jul 2018 00:00:00 +0000

Notes

This release of the Python agent adds support for Python 3.7 and contains various bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Support Python 3.7

The New Relic Python Agent now supports Python 3.7.

Bug Fixes

Agent raises a KeyError: 'NEW_RELIC_ADMIN_COMMAND' exception causing a crash

Under certain conditions, using the newrelic-admin wrapper script could cause an application to crash shortly after startup with a KeyError exception. The cause of the crash has been addressed.
Agent raises an AttributeError on Python 3 when using WSGI overrides with multiple app names

When using WSGI environ overrides to specify multiple app names as described in the docs https://docs.newrelic.com/docs/agents/manage-apm-agents/app-naming/use-m... the agent will raise an AttributeError. This error has been corrected.
Agent raises an AttributeError exception under rare conditions when halting a trace

Under certain rare conditions, the agent might raise an exception when trying to trace an external call in a transaction that has been forcibly halted. The cause of the exception has been addressed.
Agent raises a RuntimeError exception under particular conditions when using the Tornado r3 instrumentation

When attempting to yield many times from a wrapped tornado.gen.coroutine when using Tornado's r3 instrumentation, a RuntimeError due to hitting the maximum recursion limit can occur. The cause of this exception has been patched.

Python agent v4.0.0.99

Mon, 23 Jul 2018 00:00:00 +0000

Notes

This release of the Python agent removes previously deprecated APIs, and removes support for Python 2.6 and Python 3.3.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Deprecations

Removed previously deprecated APIs

The following APIs have been removed:
- Transaction.add_user_attribute (use Transaction.add_custom_parameter)
- Transaction.add_user_attributes (use Transaction.add_custom_parameters)
- wrap_callable (use FunctionWrapper)
Removed support for Python 2.6 and Python 3.3

Python 2.6 and Python 3.3 are no longer supported. Please consider upgrading your application to a supported version of Python in order to continue to receive updates to the Python Agent.

Python agent v4.14.0.115

Wed, 13 Feb 2019 00:00:00 +0000

Notes

This release of the Python agent adds support for native coroutines and generators with the background task API and adds support for Kubernetes detection.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Features

@background_task can now be used with coroutines

The background_task decorator API can now be used with native coroutines and generators.
```
@background_task(name='my_coroutine')
 async def my_coroutine():
   await asyncio.sleep(0.1)
```
Add support for collection of Kubernetes metadata

The agent will now collect environment variables prefixed by NEW_RELIC_METADATA_ as additional metadata. Some of this metadata may be added to Transaction events to provide context between your Kubernetes cluster and your services. For details on the benefits (currently in beta) see this blog post.

The agent now also collects the KUBERNETES_SERVICE_HOST environment variable to detect when the application is running on Kubernetes. The data is used to link the application to the host machine when using the New Relic infrastructure product.

Bug Fixes

Using time trace decorators allowed coroutines to become Iterables and generators to become awaitables

When using time trace decorators native coroutines were converted to iterables. Additionally generators were converted to awaitables. The behavior of generators, native coroutines, and awaitable generators is now unchanged when using time trace decorators.

Python agent v4.12.0.113

Tue, 22 Jan 2019 00:00:00 +0000

Notes

This release of the Python agent extends support of Amazon's boto3 library and includes bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Features

AWS operation and request ID will now be reported in transaction traces and spans when using boto3 and botocore.

The agent will now report aws.requestId and aws.operation for all calls to AWS made using botocore and boto3.
DynamoDB calls are now reported under the Databases tab.

The agent will now record DynamoDB query performance in the Databases tab in APM in addition to table name for the following calls:
- put_item
- get_item
- update_item
- delete_item
- create_table
- delete_table
- query
- scan
Certain SQS calls will now report additional data for spans and transaction traces.

The agent will now record the queue name in spans and transaction traces for the following SQS calls:
- send_message
- send_message_batch
- receive_message
SNS publish will now report additional data for spans and transaction traces.

The SNS topic, target, or the string literal PhoneNumber will be reported to New Relic inside of spans and transaction traces.
The full URL path will now be recorded on span events and transaction traces when using boto3 or botocore.

The agent will now record the full URL path for API calls made to AWS through the boto3 / botocore libraries. The path will be available through span events and transaction traces.

Bug Fixes

Using newrelic-admin to start a GunicornWebWorker with an aiohttp application factory resulted in an application crash.

The agent would fail to start if using the newrelic-admin command to start an aiohttp application factory with GunicornWebWorker. This issue has now been fixed.

Python agent v4.16.0.116

Mon, 25 Mar 2019 00:00:00 +0000

Notes

This release of the Python agent adds support for native coroutines and generators with a new web_transaction API, as well as bugfixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Features

Add a new web_transaction API

This method is now exposed both as a public API through newrelic.agent.api.wrap_web_transaction, and as a decorator with newrelic.agent.api.web_transaction. It can be used to instrument non-WSGI web transactions. For usage of this API see https://docs.newrelic.com/docs/agents/python-agent/python-agent-api/webt...

Bug Fixes

The presence of unicode values in a SQL query on Python 2 may cause an application crash

The agent was not properly handling unicode values when recording SQL queries in Python 2. As a result, the presence of unicode values in SQL queries in Python 2 applications may have resulted in an application crash. Unicode values in Python 2 SQL queries are now properly handled.
The Python Agent may have improperly biased the random sampling of distributed traces

Distributed traces are randomly sampled across services. The agent is responsible for propagating the state of its sampling decision to other services. In propagating that decision, an improper sampling bias may have been introduced in downstream services.
The agent will no longer report the command arguments used to start newrelic-admin

The agent previously reported the startup command and arguments when using newrelic-admin run-program and newrelic-admin run-python. The command and arguments are no longer sent to New Relic. This data may continue to be logged to the agent log files when debug level logs are enabled.

Python agent v4.18.0.118

Wed, 17 Apr 2019 00:00:00 +0000

Notes

This release of the Python agent adds improvements to the gRPC instrumentation package and includes bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Features

Improved gRPC support

Support for measuring inbound gRPC requests has now been added. Inbound gRPC requests will now show as web transactions in APM. Additionally, distributed tracing is now supported as part of the gRPC instrumentation package.

Bug Fixes

Update pika instrumentation to support the 1.x releases

When using the agent with pika versions 1.x and up, the agent may have caused an application crash. The agent now correctly collects data on newer versions of pika.
The startup_timeout setting may not have been honored in a multithreaded application

When startup_timeout is set to a number greater than 0, the servicing of transactions is blocked until the agent has fully activated. In multithreaded applications, only the first thread would block due to improper locking. The agent will now block on all threads.

Python agent v4.16.1.117

Fri, 29 Mar 2019 00:00:00 +0000

Notes

This release of the Python agent fixes a memory leak that occurs on Python 2 when monitoring WSGI applications.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Fix memory leak on Python 2 WSGI applications

When using the 4.16.0 agent on Python 2 to monitor WSGI applications, the agent would cause memory to be allocated on each request. On Python 2, this memory was never deallocated due to a reference cycle. This has now been corrected.

Python agent v4.20.0.120

Wed, 22 May 2019 00:00:00 +0000

Notes

This release of the Python agent includes bug fixes and adds new API methods to retrieve the current trace ID and current span ID.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Features

Added a new API to retrieve the current trace ID

Retrieving the current trace ID can now be accomplished with a call to newrelic.agent.current_trace_id(). This method will return the id of the current trace, or None if no transaction is in progress.
Added a new API to retrieve the current span ID

Retrieving the current span ID can now be accomplished with a call to newrelic.agent.current_span_id(). This method will return the id of the current span, or None if no span is in progress.

Bug Fixes

Exclusive time incorrectly displayed when using concurrent asyncio

The New Relic UI may have shown times equaling greater than 100 percent of the total time when executing concurrent tasks in asyncio. The exclusive times reported by the agent will now be correctly displayed in APM and insights.

Python agent v4.2.0.100

Tue, 31 Jul 2018 00:00:00 +0000

Notes

This release of the Python agent introduces distributed tracing, adds improvement to our Pyramid instrumentation, adds support for custom CA bundles, and contains bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Features

Distributed tracing support

Distributed tracing lets you see the path that a request takes as it travels through your distributed system. By showing the distributed activity through a unified view, you can troubleshoot and understand a complex system better than ever before.

Distributed tracing is available with an APM Pro or equivalent subscription. To see a complete distributed trace, you need to enable the feature on a set of neighboring services. Enabling distributed tracing changes the behavior of some New Relic features, so carefully consult the transition guide before you enable this feature.

To enable distributed tracing, add distributed_tracing.enabled = true to your newrelic.ini file or use the environment variable NEW_RELIC_DISTRIBUTED_TRACING_ENABLED=true.
Add support for tracing Pyramid tweens

Pyramid tweens are now automatically timed and added to the transaction detail view. The time spent in a Pyramid tween will be displayed in the transaction breakdown table and in the trace details of a transaction trace.
Provide configuration option for custom CA bundle

Customers can now use the ca_bundle_path configuration option or set the NEW_RELIC_CA_BUNDLE_PATH environment variable to set the path to a local CA bundle. This CA bundle will be used to validate the SSL certificate presented by New Relic's data collection service.

Bug Fixes

Custom Insights event data attached to transactions in excess of 100 events were omitted

The agent may have failed to send custom event data (record_custom_event) to insights when recorded as part of a Transaction containing over 100 custom events. This issue has now been corrected.

Python agent v4.20.1.121

Mon, 24 Jun 2019 00:00:00 +0000

Notes

This release of the Python agent includes bug fixes, deprecations, and improved naming behavior for gRPC.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Feature Enhancements

Improved gRPC support

The external and transaction pages now show the gRPC method being called in addition to the host and port.
Ability to disable sending db.statement as part of traces

When db.statement is added to either attributes.exclude or transaction_segments.attributes.exclude, the value will now no longer be sent to New Relic as part of transaction traces or spans.

Deprecations

TransactionContext API is now deprecated

The TransactionContext API will be removed in a future release.
Tornado instrumentation + feature flag deprecation

The existing introductory support for Tornado and feature flags will be removed from a future release. Versions 6.x and newer will be the only versions of Tornado supported in future releases. See this discussion on the New Relic forums for more details.

Bug Fixes

Fixed a crash when using uvicorn workers with gunicorn

When running ASGI applications with gunicorn, the agent would attempt to instrument the application as a WSGI application, resulting in a crash. The agent will no longer attempt to instrument gunicorn applications that are coroutines.
Remove logging of license keys

The agent logged license keys when data failed to send to New Relic. The agent will no longer log license keys to the agent logs under any circumstance.
Fix operation of distributed tracing and cross application tracing when httplib connections are reused

When making multiple requests via a single connection with httplib, httplib2, or urllib3, the proper headers will be added to each outgoing request. As a result, cross application tracing and distributed tracing will now operate as expected when reusing connection objects.

Python agent v4.4.0.103

Tue, 11 Sep 2018 00:00:00 +0000

Notes

This release of the Python agent introduces instrumentation for Sanic, and contains bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Features

Add instrumentation for Sanic framework

Data is now automatically collected for applications using the Sanic framework. Data for Sanic applications will appear in both APM and Insights. Additionally, cross application tracing and distributed tracing is supported for incoming requests for Sanic applications. In addition to service maps, Sanic applications will now show the calling application in transaction traces. See the instrumented packages page for more details.

Bug Fixes

Explain plans were not generated when using psycopg2 named cursors

When using named cursors in psycopg2, the agent attempted to generate an explain plan using the same named cursor. This resulted in a syntax error when the query was issued to the database. When using the default connection and cursor factories, the agent will now execute the explain query using only unnamed cursors.
Convert bytes-like SQL statements to strings before obfuscating

If a bytes-like object is used instead of a string when making a SQL call, a traceback was seen in the logs with TypeError: cannot use a string pattern on a bytes-like object. This issue has now been fixed.
Save settings to MessageTrace objects

If an external call using an instrumented http external library (for example requests) was used within a MessageTrace, a traceback was seen in the logs with AttributeError: 'MessageTrace' object has no attribute 'settings'. This issue has now been fixed.

Python agent v4.4.1.104

Mon, 24 Sep 2018 00:00:00 +0000

Notes

This release of the Python agent contains bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

The creation of sampled events sometimes raised an exception in Python 3

When more events (Transaction, Transaction Error, Custom, or Span) were created than allowed per harvest period in Python 3, sometimes a TypeError: '<' not supported between instances of 'dict' and 'dict' was raised. This issue has now been fixed.

Python agent v4.6.0.106

Mon, 12 Nov 2018 00:00:00 +0000

Notes

This release of the Python agent includes changes to the agent to enable monitoring of Lambda functions, improves the built-in Sanic instrumentation, and includes various bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Features

Monitoring of Lambda functions

This release includes changes to the agent to enable monitoring of Lambda functions. If you are interested in learning more or previewing New Relic Lambda monitoring please email lambda_preview@newrelic.com.
Improve naming of Sanic HTTPMethodView view handlers

Sanic views that were defined using the HTTPMethodView class were previously all named HTTPMethodView.as_view.<locals>.view regardless of the actual class in use. The agent will now name transactions after the actual view handler class.

Bug Fixes

Fix ignored error reporting in CherryPy instrumention

When missing query parameters, unexpected query parameters, unexpected positional arguments, or duplicate arguments were present in the CherryPy framework, a TypeError exception was recorded even when an ignored response status code (such as a 404) was generated. An error is no longer recorded when it results in the generation of an ignored status code.
Excluding request.uri from transaction trace attributes hides it in the UI

When request.uri is added to either attributes.exclude or transaction_tracer.attributes.exclude, the value will now no longer be sent to New Relic.
Ability to disable sending request.uri as part of error traces

When request.uri is added to either attributes.exclude or error_collector.attributes.exclude, the value will now no longer be sent to New Relic.
Fix tracing of functions returning generators

When tracing generators whose parent traces have ended an error was seen in the logs "Transaction ended but current_node is not Sentinel." This has now been fixed.

Python agent v5.0.0.124

Tue, 06 Aug 2019 00:00:00 +0000

Notes

This release of the Python agent introduces:

Event loop diagnostics feature
Tornado instrumentation for versions 6 or higher
Improved context manager API functionality and interfaces

This release also drops support for Python 3.4.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Event loop diagnostics

Introducing event loop diagnostics for asyncio! The Python agent can now surface information about transactions that block the event loop. The agent will be able to generate information about transactions that have waited a significant amount of time to acquire control of the event loop.

Event loop diagnostic information will be available in both APM and via NRQL query.

Event loop metrics will appear in the transaction Breakdown table:

Time spent waiting on other transactions will be shown in the transaction Trace details page, as shown here:

eventLoopTime and eventLoopWait attributes will be available via NRQL query. An example query might be:
SELECT count(*) as 'count', average(eventLoopTime) as 'loopTime', average(eventLoopWait) as 'loopWait' FROM Transaction facet name

In New Relic Insights, this might show a result like this:

Diagnostics will be available by default through our existing aiohttp, sanic, and Tornado instrumentation. Diagnostic information will also be available for coroutines that use our background_task and web_transaction decorator APIs.

Tornado 6 Instrumentation

Instrumentation for Tornado framework version 6.x is supported without any feature flags. Support for versions earlier than Tornado 6.x has been dropped. The Tornado web server, framework, and http client are instrumented and information will show up in both APM and insights.

Important: Using the tornado.gen.coroutine with instrumentation is not supported. Any usage of tornado.gen.coroutine should be replaced with an asyncio coroutine.

Before

class MainHandler(tornado.web.RequestHandler):
    @tornado.gen.coroutine
    def get(self):

        yield gen.sleep(0.2)

After

class MainHandler(tornado.web.RequestHandler):
    @asyncio.coroutine
    def get(self):

        yield from gen.sleep(0.2)

Improved APIs for time trace context managers

Context managers (such as FunctionTrace, ExternalTrace, DatastoreTrace) may now be used from within asyncio coroutines! Additionally, the transaction argument is no longer used for any context manager API. In order to transition to the new API, the transaction argument must be removed.

Before

transaction = newrelic.agent.current_transaction()
with newrelic.agent.FunctionTrace(transaction, "my_trace"):
  pass

After

with newrelic.agent.FunctionTrace("my_trace"):
  pass

Updated WebTransaction context manager

The WebTransaction context manager is no longer WSGI dependent. The context manager takes generic HTTP arguments, which you can use to build web transactions that appear in the APM product. For more information, see our API documentation.

Python agent v4.8.0.110

Mon, 03 Dec 2018 00:00:00 +0000

Notes

This release of the Python agent adds support for Falcon framework, and includes various bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Features

Add support for Falcon web framework

This release adds support for the Falcon web framework. Data will now be automatically collected for applications using Falcon framework. The data will appear in both APM and Insights and will include performance details as well as information on application errors.

Bug Fixes

"newrelic-admin record_deploy" now functions with proxies.

The newrelic-admin recorddeploy command previously did not function when a proxy was defined by the newrelic.ini configuration file or the `NEW_RELIC_PROXY*` environment variables. This bug has now been fixed.
Cross Application Tracing HTTP response headers were inserted on a 304 response

When cross application tracing is enabled and the agent received a HTTP request from an application utilizing cross application tracing, the agent may have inserted additional response headers on a 304 HTTP response. The agent will no longer insert headers on a 304 response.

Python agent v5.0.2.126

Mon, 12 Aug 2019 00:00:00 +0000

Notes

This release of the Python agent includes bug fixes for feedparser and django-piston.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Fixed a crash when using feedparser

When running with the feedparser library the agent would crash on attempting to parse an RSS feed. This issue has now been corrected.
Fixed a crash when using django-piston

When running with the django-piston library the agent would crash on attempting to service a request. This issue has now been corrected.

Python agent v5.0.1.125

Fri, 09 Aug 2019 00:00:00 +0000

Notes

This release of the Python agent includes a bug fix for the mako library instrumentation.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Fixed a crash when using the Mako template library

When running with the Mako template library the agent would crash on attempting to render a template. This issue has now been corrected.

Python agent v5.10.0.138

Mon, 09 Mar 2020 00:00:00 +0000

Notes

This release of the Python agent includes an update to the API for recording exceptions, default request attributes, optional function trace attributes, and bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Improved features

newrelic.agent.record_exception now adds attributes to spans

The public API method newrelic.agent.record_exception now attaches exception details to the currently executing span. Spans with error details are now highlighted red in the distributed tracing UI. Also, the attributes error.class and error.message are added to the span. If multiple errors are recorded for a single span, only the final error's attributes will be added to the span.
Note: Exceptions recorded on spans may be double counted in the distributed tracing UI.
New default web request attributes.

The previously optional attributes request.headers.accept, request.headers.host, and request.headers.userAgent are now included by default on all web transactions. These attributes can be excluded through agent configuration.
peer.address and peer.hostname can now be excluded from spans through configuration

peer.address and peer.hostname may be excluded from span events through attribute.exclude options in the agent configuration.

Bug fixes

Fix issue which could potentially lead to missing event data

When the agent was shutting down, event harvest may have been skipped causing any events captured in the final 5 seconds of application execution to be discarded. This has now been fixed.
Runtime instrumentation error messages for calling __exit__ before __enter__ were erroneously logged

Under certain conditions, the agent may have logged an error message for transaction __exit__ being called before trace __enter__. This error message is now printed only if the error condition is true.

Known issues and workarounds

If a .NET agent is initiating distributed traces as the root service, you must update that .NET agent to version 8.24 or later before upgrading your downstream New Relic Python agents to this agent release.

Python agent v5.12.0.140

Mon, 13 Apr 2020 00:00:00 +0000

Notes

This release of the Python agent includes support for a new product called Infinite Tracing, and it also has some bug fixes

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Feature

This release adds support for Infinite Tracing. Infinite Tracing observes 100% of your distributed traces and provides visualizations for the most actionable data. With Infinite Tracing, you get examples of errors and long-running traces so you can better diagnose and troubleshoot your systems.

Configure your agent to send traces to a trace observer in New Relic Edge. View distributed traces through New Relic’s UI. There is no need to install a collector on your network.

Infinite Tracing is currently available on a sign-up basis. If you would like to participate, please contact your sales representative.

Bug fixes

Fix record transaction failure in async applications

When the agent attempted to record information as part of event loop diagnostics, an AttributeError may have occurred during the record transaction phase causing data to not be recorded for that transaction. This issue has now been fixed.

Python agent v5.12.1.141

Mon, 04 May 2020 00:00:00 +0000

Notes

This release of the Python agent includes bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug fixes

AIOHTTP http client urls displayed as unknown.url when using YARL URLs

When passing a YARL url object to the aiohttp client, the agent did not properly parse this URL, resulting in unknown.url being displayed in the UI. The URL is now parsed correctly in both the YARL url case and the string url case.
Data may not be recorded when tornado's RequestHandler.finish

Using RequestHandler.finish in tornado caused the transaction to exit before all traces (inserted by automatic instrumentation) were complete, resulting in missing data. All traces now exit when RequestHandler.finish is called.
asyncio.ensure_future / asyncio.create_task is unable to spawn new transactions

Calling asyncio.create_task / asyncio.ensure_future was unable to spawn a new transaction if these methods were called from within an existing transaction. New transactions can now be created when ensure_future/create_task is called from within an existing transaction and no traces have been started on the spawned task.
py3: A runtime instrumentation error may have occurred when transactions were finalized

When transactions became garbage (if the reference to the transaction was lost as part of a circular reference for example), a runtime instrumentation error may have been logged. The error conditions have been relaxed to allow for certain states within the agent when a transaction becomes garbage.
Application crash when starting a transaction when one is already active

Starting a transaction via the context manager APIs when a transaction is already active no longer causes an application crash. An error is logged when this case is detected.
Creating a message transaction with distributed tracing enabled may have resulted in a crash

The agent crashed with an AttributeError when using message transactions with distributed tracing enabled when headers were not provided. This error has been fixed.

Python agent v5.14.0.142

Tue, 02 Jun 2020 00:00:00 +0000

Notes

This release of the Python agent includes improvements to distributed tracing, and bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Add new span attribute transaction.name

A new attribute, transaction.name, has been added to the root span.

Improved features

Transaction attributes are added to the root span

Transaction attributes, including response attributes, are now added to the root span.
Custom attributes are added to the root span

The public API methods newrelic.agent.add_custom_param and newrelic.agent.add_custom_params now add the specified custom attribute to the root span in addition to the transaction. If the maximum number of custom attributes is reached, span-level custom attributes take precedence over transaction-level custom attributes.
Error attributes added to each span/segment

Error attributes error.class and error.message to all spans that exit without handling an exception.

Bug fixes

asyncio: application crash when a transaction that started on a completed parent task exits

When a transaction that started on a completed parent task exited, an exception was raised. This error has been fixed.
Error attributes are no longer added if the error collector is disabled

If the error collector is disabled via error_collector.enabled, error attributes error.class and error.message are not added to the currently executing span.

Security Updates

Note that changes were made that add attributes to the root span. Transaction-level attribute filtering via the transaction.attribute.exclude configuration setting will not filter the attribute(s) for the root span. Those attributes may unexpectedly start to appear on the root span.

Python agent v5.14.1.144

Thu, 18 Jun 2020 00:00:00 +0000

Notes

This release of the Python agent includes a bug fix.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug fixes

When using newrelic-admin run-program on Python 2.7 applications failed to start

Using the newrelic-admin run-program on Python 2.7 with the 5.14.0 agent resulted in an application crash. Applications now start as expected on Python 2.7.

Python agent v5.16.0.145

Mon, 10 Aug 2020 00:00:00 +0000

Notes

This release of the Python agent changes the internal http client from requests to urllib3, updates logging, and includes bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Improved Features

The NewRelicContextFormatter now records extras

When using the NewRelicContextFormatter log formatter, extras are now automatically captured and recorded in the New Relic agent logs product.
The agent now internally uses urllib3

The python agent previously used requests as its http client. The agent now uses urllib3 internally for HTTP communication with New Relic data ingest services.

Bug fixes

Fix gRPC application crash when credentials are supplied

When using the credentials argument, the agent's built in gRPC instrumentation caused an application crash. This crash has been fixed.
Fix Tornado framework crashes when finish is called from a different task

When finish is called from a different task, applications using the Tornado framework may crash. This crash has been fixed.

Python agent v5.16.1.146

Mon, 17 Aug 2020 00:00:00 +0000

Notes

This release of the Python agent introduces manylinux wheels and includes bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug fixes

Data was erroneously discarded when an HTTP protocol error occurred

When an unexpected HTTP error occurred (such as a timeout), data was erroneously discarded. Data is now downsampled and retransmitted when an HTTP protocol error occurs.
Error when installing with an incompatible setuptools_scm version

The version requirements were not correctly set for the setuptools_scm build time requirement, which may have resulted in an error at installation. The version requirements for setuptools_scm are now set appropriately.

Python agent v5.16.2.147

Mon, 24 Aug 2020 00:00:00 +0000

Notes

This release of the Python agent includes bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug fixes

Fix invalid payloads generated when using serverless mode

When using serverless mode on the Python Agent versions v5.16.0 and v5.16.1, invalid serverless/lambda payloads were generated. The agent now generates the proper payloads in serverless mode.

Python agent v5.18.0.148

Mon, 31 Aug 2020 00:00:00 +0000

Notes

This release of the Python agent adds new ASGI apis and upgrades wrapt.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Adds support for ASGI applications via built in APIs

ASGI applications can now be timed via middleware-like API calls. Browser monitoring JS is automatically injected into HTML pages by the ASGI browser monitoring middleware for instrumented applications. See the asgi_application docs for details on API usage.
Upgrades wrapt to 1.12.1

This version of the agent ships with wrapt 1.12.1.

Python agent v5.20.1.150

Tue, 06 Oct 2020 00:00:00 +0000

Notes

This release of the Python agent adds support for Python 3.9 and includes bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Duplicate warnings were logged repeatedly when using the agent with Python 3

The agent internally suppressed any warnings generated when data was sent via HTTP to New Relic in a way that caused the warning filters to mutate. This caused the cache of already printed warnings to be cleared, resulting in duplicate warnings after every data harvest. The agent no longer mutates the process warning filters on a background thread, resulting in consistent warning behavior.
AttributeError when passing an inactive transaction into ExternalTrace.generate_request_headers

When passing an inactive transaction into ExternalTrace.generate_request_headers, an AttributeError was generated. This agent version contains additional validation for the transaction argument in ExternalTrace.generate_request_headers.
The infinite tracing host configuration value did not have sufficient validation

When passing a URL or other invalid host to the infinite tracing host configuration, the agent accepted this value unchecked to use in the host parameter for later connections via grpc. The agent now validates this configuration and attempts to correct for invalid hosts if it is able to detect the host. If a host is not detected, the agent automatically falls back to infinite tracing disabled and logs an error.

Python agent v5.2.0.127

Tue, 01 Oct 2019 00:00:00 +0000

Notes

This release of the Python agent includes a bug fix for tornado and support for recording deployment markers in the EU region as well as specifying a deploy timestamp.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Features

Support for Real Time Streaming
- Event data is now sent to New Relic every five seconds, instead of every minute. As a result, transaction, error, and custom events will now be available in New Relic and Insights dashboards in near real time. For more information on how to view your events with a five-second refresh, see the real time streaming documentation.
- Note that the overall limits on how many events can be sent per minute have not changed. Also, span events, metrics, and trace data is unaffected, and will still be sent every minute.
Added timestamp and EU region support for recording deployment markers

When using the newrelic-admin record-deploy script an optional timestamp can be provided to specify when the deployment marker should be created. Furthermore support for accounts in the EU region have been added in this release.

Bug Fixes

Fixed a crash in tornado versions >= 6.1

Tornado 6.1 internals changed in a way that may have caused the agent's built-in instrumentation to fail. The instrumentation has been updated to alleviate this issue.

Python agent v5.2.1.129

Wed, 09 Oct 2019 00:00:00 +0000

Notes

This release of the Python agent includes bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Fix a crash when using future-based interfaces on Tornado's http client

Tornado's http client returns a future when fetch is called. Prior to this release, the agent caused a coroutine object to be returned rather than a future, causing a potential crash when application code assumed a future would be returned. A future will now be returned from http client fetch as expected.
Fix a crash when running a coroutine created in another transaction

When running a coroutine outside of the transaction that created it, the agent may have crashed if a separate transaction was active.

Python agent v5.22.0.151

Thu, 22 Oct 2020 00:00:00 +0000

Notes

This release of the Python agent adds instrumentation for Starlette and FastAPI.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Deprecations

Python 3.5 has been deprecated

Python 3.5 has reached end of life and support will be dropped in a future release. Using the agent with Python 3.5 will generate a deprecation warning. Updating Python versions is recommended.

New Features

Adds Starlette framework instrumentation

Starlette applications will now be automatically instrumented. Transaction data will be collected and recorded for application routes, background tasks, exception handlers, and installed middleware. Exception logging has also been added.
Adds FastAPI framework instrumentation

FASTAPI applications will also now be automatically instrumented. See above for instrumentation details.

Bug Fixes

Fix deprecation warning for find_loader in python 3

Using the agent no longer generates a deprecation warning for find_loader. The call to find_loader has been replaced with find_spec.

Python agent v5.20.0.149

Mon, 21 Sep 2020 00:00:00 +0000

Notes

This release of the Python agent adds instrumentation for uvicorn and asyncpg.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Adds uvicorn instrumentation

ASGI applications are now automatically wrapped when using the uvicorn ASGI server.
Adds asyncpg instrumentation

Support has been added for recording database transactions when using asyncpg database client module for PostgresSQL.

Improved Features

Adds db.operation attribute

A new attribute, db.operation, was introduced for datastore traces. This value is recorded only when db.statement is not reported, and represents an operation triggered by methods other than running a DB statement.

Python agent v5.2.2.130

Wed, 06 Nov 2019 00:00:00 +0000

Notes

This release of the Python agent includes bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Fix thread utilization data on agent versions v5.x.x

Thread utilization data was not reported for agents v5.x.x, resulting in missing data on the capacity analysis page. The agent will now report thread utilization data.
Fix untraced database calls when using pymysql context manager assignments

When using context managers to create and assign a cursor in pymysql, database calls on that cursor object were not traced. Database calls in pymysql are now properly traced.

Python agent v5.22.1.152

Wed, 28 Oct 2020 00:00:00 +0000

Notes

This release of the Python agent updates transaction naming for Starlette and FastAPI, and includes bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Improved Features

Updated transaction naming for middleware in Starlette and FastAPI

The transaction naming hierarchy has been updated for Starlette and FastAPI applications. The web transaction name is named after the route handler, or after middleware if an exception is raised in the middleware.

Bug Fixes

RuntimeError for imports occurring on a background thread

A RunTimeError was being raised in the event of imports occurring on a background thread during iteration over sys.modules. This issue has been resolved in this agent version.
Fixed region aware license key default host setting

This agent version contains a fix for setting the default host value based on the license key for EU license keys. Setting the host manually will still override the default host value set by the license key.

Python agent v5.2.3.131

Wed, 13 Nov 2019 00:00:00 +0000

Notes

This release of the Python agent includes support for Python 3.8 and restores the original record-deploy command interface.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Updates

Added Support for Python 3.8

Python 3.8 support has been added in this release.
Restore newrelic-admin record-deploy command interface

The newrelic-admin command was previously updated to require an application id via the command line. The requirement has been removed, restoring the original record-deploy CLI arguments.

Python agent v5.4.0.132

Tue, 26 Nov 2019 00:00:00 +0000

Notes

This release of the Python agent includes the logs in context feature and bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Features

Logs In Context

The logs in context feature is now supported by the PythonaAgent. For more information, see the Python logs-in-context page.

Bug Fixes

The plugin list in the environment page may have been inaccurately reported

When using absolute imports in Python 2, the agent may have reported relative imports that were attempted but unsuccessful. Python 3 is not impacted. Modules are now reported correctly in Python 2.

Python agent v5.24.0.153

Tue, 22 Dec 2020 00:00:00 +0000

Notes

This release of the Python agent includes minor bug fixes.

Bug Fixes

Fix incorrect wrapper in grpc instrumentation.

_MultiThreadedRendezvous._next was wrapped with the instrumentation designed for _MultiThreadedRendezvous.result. This issue has been resolved as of this agent version.

Python agent v5.4.1.134

Thu, 19 Dec 2019 00:00:00 +0000

Notes

This release of the Python agent includes a bug fix for reporting inaccurate metric values.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Metrics may be reported with an incorrect throughput after communication failure with New Relic

For agent versions 5.2.0 through 5.4.0, metric throughput may have been reported inaccurately after experiencing network / communication failures with New Relic. The throughput reported for all metrics after this failure may have been abnormally high.

Python agent v5.6.0.135

Mon, 03 Feb 2020 00:00:00 +0000

Notes

This release of the Python agent includes an implementation for w3c trace context, support for uvloop, and various bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

New APIs for creating / accepting distributed trace headers

This version of the agent deprecates newrelic.agent.create_distributed_trace_payload and newrelic.agent.accept_distributed_trace_payload in favor of newrelic.agent.insert_distributed_trace_headers and newrelic.agent.accept_distributed_trace_headers. See the Python agent API documentation for details.
Support for W3C Trace Context, with easy upgrade from New Relic Trace Context

Distributed Tracing now supports W3C Trace Context headers for HTTP and gRPC protocols when distributed tracing is enabled. Our implementation can accept and emit both W3C trace header format and New Relic trace header format. This simplifies agent upgrades, allowing trace context to be propagated between services with older and newer releases of New Relic agents. W3C trace header format will always be accepted and emitted. New Relic trace header format will be accepted, and you can optionally disable emission of the New Relic trace header format.

When distributed tracing is enabled with distributed_tracing.enabled = true, the Python agent will now accept W3C's traceparent and tracestate headers when calling accept_distributed_trace_headers. When calling insert_distributed_trace_headers, the Python agent will include the W3C headers along with the New Relic distributed tracing header, unless the New Relic trace header format is disabled using distributed_tracing.exclude_newrelic_header = true

Also, see the "Known Issues and Workarounds" section of these Release notes.

Improved Features

Add support for uvloop

Transaction context may not have been propagated when using uvloop. This could have resulted in incomplete traces or instrumentation failures when using uvloop. uvloop is now supported.

Bug Fixes

Fix crash when using aiohttp_cors

Customers using the agent with aiohttp_cors may have experienced a crash when the aiohttp_cors framework was used in conjunction with aiohttp class based views. This crash has now been fixed.
Fix grpc v1.26 instrumentation errors

Customers using grpc v1.26 and above may have experienced an error message in the New Relic agent logs indicating there was an instrumentation error. Additionally, some data may have been missing when this error was encountered. This issue has now been fixed.

Known Issues and Workarounds

If a .NET agent is initiating distributed traces as the root service, you must update that .NET agent to version 8.24 or later before upgrading your downstream New Relic Python agents to this agent release.

Python agent v6.0.0.154

Thu, 21 Jan 2021 00:00:00 +0000

Notes

This release of the Python agent adds instrumentation for httpx, removes support for Python 3.5, and includes performance enhancements.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Deprecations

Removed support for Python 3.5

Python 3.5 is no longer supported by the agent. Please consider upgrading your application to a supported version of Python in order to continue to receive updates to the Python Agent.

New Features

Added httpx instrumentation

External web service requests made with the httpx client module will now be automatically instrumented.
Added Django ASGI instrumentation

Django's ASGI mode will now be supported through automatic instrumentation.

Improved Features

Improved startup performance

The loading of urllib3 is now delayed and happens on a background thread which improves overall initialization time.

Bug Fixes

Non-ASCII HTTP referers crash fix

Crashes had occurred when non-ASCII HTTP referers were passed to ASGI applications. This crash no longer occurs as of this release.

Python agent v5.8.0.136

Mon, 24 Feb 2020 00:00:00 +0000

Notes

This release of the Python agent includes a new API for adding custom attributes on span events, improvements to external type spans, deprecations, and bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New features

Add new api newrelic.agent.add_custom_span_attribute

There is now a public API method allowing users to add custom attributes directly to spans.

Improved features

External spans now contain HTTP response code

External HTTP spans will now contain a new attribute http.statusCode with the http response code for each external call made. This attribute will be added when using any supported HTTP client.

Deprecations

LambdaHandlerWrapper and lambda_handler APIs are deprecated

The Lambda API functionality has been moved to a separate package called newrelic-lambda. All future lambda implementations should use the new package for lambda monitoring.

Bug fixes

Fix application crash when using a non-WSGI framework with synthetics

When synthetic monitors were used with an application utilizing a non-WSGI web framework (such as aiohttp), a crash could have occurred if an outbound HTTP request was attempted from within the transaction. This crash has now been fixed.
The Python agent generates an invalid nr tracestate entry

Under certain random conditions, the agent may have generated an invalid New Relic w3c tracestate entry, resulting in potentially missing parts of traces. This invalid tracestate entry would not impact propagation of tracestate values from other vendors.

Known issues and workarounds

If a .NET agent is initiating distributed traces as the root service, you must update that .NET agent to version 8.24 or later before upgrading your downstream New Relic Python agents to this agent release.

Python agent v6.4.0.157

Tue, 25 May 2021 00:00:00 +0000

Notes

This release of the Python agent deprecates the old record_exception API, replaces the error_collector.ignore_errors setting, adds a new notice_error API, adds expected errors functionality, improves the NewRelicContextFormatter, and fixes multiple bugs including a few potential crashes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Deprecations

Deprecated record_exception API

record_exception has been superseded by the new notice_error API. The old API will forward exceptions to notice_error with a deprecation warning.
Deprecated error_collector.ignore_errors setting

error_collector.ignore_errors has been replaced with error_collector.ignore_classes to match other agents. Please update your config files to use the new setting. The old setting will continue to function with a deprecation warning.

New Features

Added new notice_error API

This new API falls much more in line with other language agents.

It also includes expected errors functionality and a status code parameter.

To see all changes, view the documentation for this API.

Added new expected errors feature

This feature implements expected errors as documented here. To enable them, use the following new settings.
- error_collector.expected_classes
- error_collector.expected_status_codes

Improved Features

Improved NewRelicContextFormatter

Adds new log_record_to_dict function to separate logic for JSON serialization and converting to a dictionary, enabling custom formatters to access the data more easily.

Custom attributes now attempt JSON serialization by default and fallback to strings, meaning dictionaries and other serializable types are now supported.

Thank you to @chrislawlor and @qvik-olli for your contributions!
error_collector.ignore_status_codes is now configurable in server-side configuration

Previously this setting was only available in the config file, but is now available via server-side configuration.

Bug Fixes

Infinite tracing crash fix

Crashes had occurred in infinite tracing following the inclusion of some startup timeout changes in v6.0.0. These changes have been rolled back.
RuntimeInstrumentationError crash removed

Crashes occurred when a RuntimeInstrumentationError was reached, indicating a potential problem with existing instrumentation. The exception is now caught and replaced with error level log messages to avoid crashing applications.
SQLite instrumentation consumes generator objects passed to executemany

A generator passed to Connection.executemany would unexpectedly be consumed by our instrumentation. This has been corrected and generators are now properly supported.

Known Issues

Flask v2.0.0 support

Flask released a new major version recently that we do not yet support, but expect to in the near future.
Sanic support

Sanic has released large changes to the framework recently that have broken some of our instrumentation on certain versions, and can crash the agent on others. We expect to correct these issues in the near future.

Python agent v6.0.1.155

Thu, 21 Jan 2021 00:00:00 +0000

Notes

This release of the Python agent includes a bug fix for httpx instrumentation.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

httpx process response attribute error

In httpx instrumentation, an attribute error was occurring during processing of the HTTP response. This issue was resolved in this release.

Python agent v6.4.1.158

Fri, 04 Jun 2021 00:00:00 +0000

Notes

This release of the Python agent adds support for Flask v2, improves logging for HTTP exceptions, and includes a bug fix.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Add support for Flask v2

The agent will automatically instrument error handlers, nested blueprints, and async views.

Improvements

Improve logging for 410 status codes

The agent now logs the content of a data collector response which specifies the reason for a disconnect for 410 status codes.

Bug Fixes

Reintroduce non-PID specific memory metrics

In agent version v6.2.0.156, memory metrics were modified to add the PID to each metric name. This release reintroduces non-PID specific memory metrics.

Python agent v6.4.2.159

Tue, 22 Jun 2021 00:00:00 +0000

Notes

This release of the Python agent updates Sanic instrumentation to support all available versions.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Improvements

Update Sanic instrumentation

The agent has updated support for all Sanic versions, with testing done on all versions >=18.12.0. Additionally, blueprint middleware is now supported.
Update Pyramid transaction naming

Previously, transaction names from exception views overrode route names. We've reversed this priority to be more in line with other instrumentation.

Bug Fixes

Fix inspect.formatargspec deprecation warning

A deprecation warning concerning inspect.formatargspec has been fixed.
Fix HTTPX crash

Initializing the agent after creating an HTTPX client could cause a crash in HTTPX. This has been corrected.

Python agent v6.4.3.160

Wed, 23 Jun 2021 00:00:00 +0000

Notes

This release of the Python agent includes a bug fix related to middleware and background tasks in Starlette/ FastAPI.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

Bug Fixes

Fix Starlette/ FastAPI transaction naming and classification

Starlette/ FastAPI routes that contained middleware and background tasks were being incorrectly classified as non-web transactions and named after the background task rather than the route. This has been corrected in this release.

Python agent v6.4.4.161

Tue, 06 Jul 2021 00:00:00 +0000

Notes

This release of the Python agent adds wildcarding to instrumentation config and fixes a crash in the memory metric sampler.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Improvements

Add wildcard matching to instrumentation via config file

The agent now supports wildcards for classes and functions when instrumenting via config file. Note: this does not include module paths.

Bug Fixes

Fix a crash in memory sampling on BSD kernels

A crash in the memory metric sampler was possible when using kernels besides MacOS and Linux. This has been corrected.

Python agent v6.6.0.162

Thu, 29 Jul 2021 00:00:00 +0000

Notes

This release of the Python agent adds new GraphQL instrumentation support for the Graphene library and Graphene schemas created in Starlette/ FastAPI.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Add support for Graphene

Graphene applications will now be automatically instrumented.

Add support for Graphene schemas in Starlette/FastAPI with use of an AsyncioExecutor

Starlette/ FastAPI applications using GraphQL in conjunction with an AsyncioExecutor will now be automatically instrumented.

Python agent v6.8.0.163

Wed, 04 Aug 2021 00:00:00 +0000

Notes

This release of the Python agent adds ARM64 wheels and fixes a crash in unsupported GraphQL versions.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New Features

Add wheel support for ARM64 (a.k.a. AArch 64, ARMv8)

The agent now provides prebuilt wheels for ARM64 for Python versions >=3.6. This requires a version of pip>=19.3.

Bug Fixes

Fix a crash in unsupported GraphQL versions

A crash in GraphQL could occur when using an older version not supported by our instrumentation (ie. graphql-core<2.1). This has been corrected.

Python agent v6.10.0.165

Thu, 16 Sep 2021 00:00:00 +0000

Notes

This release of the Python agent adds new instrumentation for the GraphQL frameworks Strawberry and Ariadne, updates to Graphene and Starlette GraphQL instrumentation, a change to logging configuration, and includes bug fixes.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New Features

Add new instrumentation for Strawberry

GraphQL applications built using Strawberry will now be automatically instrumented.
Add new instrumentation for Ariadne

GraphQL applications built using Ariadne will now be automatically instrumented.

Improvements

Add new and changed metrics for Graphene applications

Metrics specifying the framework details for Graphene have been added, and GraphQL metrics now include Graphene as a product field.

(eg. GraphQL/operation/Graphene/query/<query_name>/<query_path>)
Improve tracing in Starlette GraphQL applications

GraphQL applications using Starlette now support all executor classes. Previously, only async executor classes were supported.

Changes

New Relic agent logs no longer propagate to the root logger by default

Previously, logs using the logging module sent to the newrelic logger would propagate to the root logger, potentially causing duplicate logs to appear or be sent to New Relic. This has been changed to no longer propagate to the root logger by default.

To reverse this behavior, in your application you can run logging.getLogger("newrelic").propagate = True at any point after initializing the agent. If you use the newrelic-admin wrapper, this can be done at any time inside your application.

Bug Fixes

TimeTrace.str recursion

A case of infinite recursion with TimeTrace.__str__ has been corrected in this release. Calling str(), repr() or print() on a TimeTrace object or subclass instance will now display helpful debugging information about it.

Python agent v6.8.1.164

Tue, 24 Aug 2021 00:00:00 +0000

Notes

This release of the Python agent updates the log file location in the default newrelic.ini file, and includes multiple bug fixes.

The agent can be installed using easy_install/pip/distribute via the Python Package Index, or it can be downloaded directly from the New Relic download site.

Improved Features

Update log_file location in default newrelic.ini

The newrelic.ini generated using newrelic-admin generate-config has been updated to set the default log_file location to stdout for improved initial visibility. This setting can still be customized to log to stderr or a user-specified file as well.

Bug Fixes

Handle cherryPy.HTTPRedirects

cherrypy.HttpRedirects were incorrectly being reported as errors. This has now been corrected thanks to a contribution from @bdeeney!
Address DeprecationWarning for invalid escape sequence

A deprecation warning concerning unrecognized escape sequences in Python 3.6 (and higher) has been fixed. Thank you @urianchang for your contribution!

Python agent v6.2.0.156

Thu, 25 Feb 2021 00:00:00 +0000

Notes

This release of the Python agent includes new garbage collection runtime metrics as well as improved metrics for CPU and memory usage. This release also includes bug fixes for Uvicorn instrumentation and FIPS compliant systems.

The agent can be installed using easy_install/pip/distribute via the Python Package Index or can be downloaded directly from the New Relic download site.

New Features

Adds garbage collection runtime metrics.

Records statistics as metrics after garbage collection sweeps. This feature is disabled by default and can be enabled and configured with these settings.

Improved Features

Improved CPU metric sampling.

Adds separate metrics for user time, system time, and total time as well as utilization as a percentage for each.
Improved memory metric sampling.

Adds memory utilization as a percentage, and adds PID to metrics to allow faceting in NRQL queries.
Increased custom attribute limit from 64 to 128.

The custom attribute limit affects user added attributes on spans, events, and transactions.

Bug Fixes

Fixed a TypeError with Uvicorn and unix sockets.
Fixed a crash when using a FIPS compliant system with Cross Agent Tracing enabled.

Python agent v7.0.0.166

Wed, 22 Sep 2021 00:00:00 +0000

Notes

This release of the Python agent enables Distributed Tracing by default, deprecates Cross Application Tracing.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New Features

Reservoir sizes now configurable using settings and environment variables

Reservoir sizes for span events, transaction events, error events, and custom events are now configurable via environment variables. These reservoirs limit both the maximum number of events that can be sent as well as local memory usage.

The agent reservoir can be expanded to accommodate more spans in case more traces are needed or there are dropped spans. The default setting for event_harvest_config.harvest_limits.span_event_data has been increased from 1000 to 2000 for better performance. This variable can be increased up to a size of 10,000.

These settings previously existed via config file but were undocumented. For details, see the new documentation.

Deprecations

Cross Application Tracing is now deprecated, and disabled by default

Distributed Tracing is replacing Cross Application Tracing as the default means of tracing between services. Cross Application Tracing will soon be removed entirely with a future release.

The default setting for cross_application_tracer.enabled is now False, disabling Cross Application Tracing.

To continue using it temporarily while transitioning to Distributed Tracing, enable it with cross_application_tracer.enabled = True and distributed_tracing.enabled = False.

Changes

Distributed Tracing is enabled by default

The default setting for distributed_tracing.enabled is now True, enabling Distributed Tracing by default.

To disable Distributed Tracing, please set the distributed_tracing.enabled setting to False.

Python agent v7.2.3.170

Thu, 04 Nov 2021 00:00:00 +0000

Notes

This release of the Python agent fixes an issue with FastAPI instrumentation, as well as restricts gRPC to compatible versions.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Bug Fixes

Fix FastAPI context propagation error

A runtime instrumentation error stemming from context propagation in FastAPI has been fixed.
Fix gRPC incompatibilities

The version of gRPC has been pinned until compatiblity can be ensured with newer versions.

gRPC recently enabled retries by default on channel connections, potentially causing a storm of requests and open threads to starve the host of resources, as well as strain our trace observers. This pin should alleviate these issues until retries can be properly configured.

Python agent v7.2.0.167

Tue, 12 Oct 2021 00:00:00 +0000

Notes

This release of the Python agent adds supported builds for Python 3.10 and fixes bugs.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New Features

Add Python 3.10 wheels

Wheels for Python 3.10 are now available and supported.

Changes

Upgrade internal urllib3 to v1.26.7

The internal copy of urllib3 has been upgraded to v1.26.7 to address Python 3.10 issues and deprecation warnings.

Bug Fixes

Ensure errors are ignored by server-side config

Previously it was possible on transaction exit to have an error fail to be ignored when the settings were supplied via server-side config. This has been fixed.
Deprecation warnings for imp module removed

The imp module has been deprecated for some time, and has been issuing warnings. This module has been replaced with importlib when available.

Older versions of Python may still require the use of imp, but no deprecation warnings should be emitted.

Python agent v7.2.1.168

Tue, 12 Oct 2021 00:00:00 +0000

Notes

This release of the Python agent adds a patch to correctly build wheels for Python 3.10.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Bug Fixes

Fix wheels for Python 3.10

An incorrect version of cibuildwheel failed to create Python 3.10 wheels. This has been fixed and wheels should now be available.

Python agent v7.2.2.169

Fri, 15 Oct 2021 00:00:00 +0000

Notes

This release of the Python agent fixes an issue with urllib recursion as well as an import error caused by non-ASCII characters in comments

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Bug Fixes

Fix urllib3 recursion regression

Urllib3 recursion regression issue that was seen in Gevent has been fixed
Fix import error caused by non-ASCII character in comments

An import error caused by non-ASCII characters has been fixed to the correct quotation formatting

Python agent v7.2.4.171

Thu, 11 Nov 2021 00:00:00 +0000

Notes

This release of the Python agent fixes an issue with infinite tracing's usage of gRPC allowing subchannels to retry, and fixes failing database traces.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Bug Fixes

Fix gRPC retry logic

Previously gRPC subchannels left open by infinite tracing could cause network congestion and strain our trace observers. This issue has been corrected. As such, specific versions of gRPC are no longer required.
Fix crash in database trace

A crash in database traces resulting from nullified settings (seen rarely in Django) has been corrected.

Python agent v7.6.0.173

Fri, 25 Feb 2022 00:00:00 +0000

Notes

This release of the Python agent adds support for Aredis, upgrades to the AWS metadata endpoint to IMDSv2, and fixes attribute errors with the garbage collector sampler.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for Aredis The agent will now automatically instrument and send metrics for applications using the StrictRedis client from Aredis.

Changes

Upgrades to the AWS Metadata Endpoint Upgrades the AWS metadata endpoint to IMDSv2.

Bug fixes

Fix Garbage Collection Sampler Attribute Errors A crash caused by an attribute error on the garbage collector sampler has been fixed.
Safeguards Against Lost Data with Infinite Tracing Fixed race condition between agent and gRPC that resulted in loss of data on agent reconnect.

Python agent v7.4.0.172

Thu, 20 Jan 2022 00:00:00 +0000

Notes

This release of the Python agent adds support for Django v4, Redis v4, GraphQL v3.2, as well as fixes to the memory sample exception, Graphene framework, and import hook warnings for Python 3.10.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for Django v4 The agent will now automatically instrument and send metrics for applications using Django v4.
Add support for Redis v4 The agent will now automatically instrument and send metrics for applications using Redis v4.
Add support for graphql-core v3.2.0 The agent will support the latest version of GraphQL.

Changes

Fix Graphene framework details Data on graphene framework details was missing on newer versions, this has been fixed.

Bug fixes

Fix memory sample exception This fixes the crash in memory sampler on non-supported systems.
Fix import hook warnings for Python 3.10 An ImportWarning that was emitted when importing the agent in Python 3.10 has been corrected.

Python agent v7.8.0.174

Thu, 31 Mar 2022 00:00:00 +0000

Notes

This release of the Python agent adds support for GraphQL Server, adds a log handler which forwards logs to the New Relic API, and increases functionality to notice_error.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for GraphQL Server The agent will now automatically instrument and send metrics for applications using the GraphQL Server.
Add a Log Handler The agent is now able to forward logs to the New Relic API. Thank you to iamr0b0tx for your contribution!

Changes

More Robust should_ignore_error calls Pass references to settings where possible to should_ignore_error and makes custom _nr_ignored logic more defined and incorporated into notice_error.

Python agent v7.10.0.175

Wed, 06 Apr 2022 00:00:00 +0000

Notes

This release of the Python agent adds CodeStream integration support which includes code level metrics.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add integration with CodeStream Now Introducing Code-Level Metrics! Golden Signals visible in your IDE through New Relic CodeStream. Learn more here. For any issues or direct feedback, please reach out to support@codestream.com

Python agent v7.14.0.177

Mon, 27 Jun 2022 00:00:00 +0000

Notes

This release of the Python agent adds support for aioredis, enhances support for redis and aredis, and fixes a deprecation.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for aioredis

The agent will now automatically instrument and send metrics for applications using the Redis and StrictRedis clients for aioredis.

Improvements

Enhance support for redis and aredis

The agent now instruments a more extensive list of commands for redis and aredis clients. This includes commands under the search, graph, time series, json, sentinel, and bf modules.

Bug Fixes

Fix threading.currentThread deprecation

threading.currentThread was deprecated in Python 3.10 and has been replaced with threading.current_thread. Thank you hugovk for your contribution to the agent!

Support statement

New Relic recommends that you upgrade the agent regularly and at a minimum every 3 months. As of this release, the oldest supported version is 5.0.0.124.

Python agent v7.16.0.178

Thu, 21 Jul 2022 00:00:00 +0000

Notes

This release of the Python agent enables log forwarding to New Relic by default. It also addresses a bug related to compressed bytes calculations and adds a new top level data usage supportability metric to the agent.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add APM logs in context

Automatic application log forwarding is now enabled by default. This version of the agent will automatically send enriched application logs to New Relic. To learn more about about this feature, see the APM logs in context documentation. For additional configuration options, see the Python logs in context documentation. To learn about how to toggle log ingestion on or off by account, see our documentation to disable automatic logging via the UI or API.
Add top level aggregated data usage supportability metric

The agent now reports a top level data usage supportability metric: Supportability/Python/Collector/Output/Bytes. This aggregates all uncompressed bytes across all agent methods sent to New Relic.

Changes

Change data usage supportability metric name

Previously, the agent reported data usage supportability metrics in the format Supportability/Python/Collector/Output/Bytes/<agent_method>. This has been changed to be in the format Supportability/Python/Collector/<agent_method>/Output/Bytes to align with the agent specification.

Bug fixes

Fix data usage supportability metric compression payload calculation

Previously, the agent was reporting the compressed bytes for the Supportability/Python/Collector/Output/Bytes metric group and uncompressed bytes for the Supportability/Python/Collector/ZLIB/Bytes metric group. This was incorrect and has been fixed in this release.

Support statement

New Relic recommends that you upgrade the agent regularly and at a minimum every 3 months. As of this release, the oldest supported version is 5.0.0.124.

Python agent v7.12.0.176

Thu, 09 Jun 2022 00:00:00 +0000

Notes

This release of the Python agent adds APM logs in context. Additionally this release fixes issues in Starlette and gRPC version compatibility, renames whitelist settings, and removes unwanted error logs.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add APM logs in context

A quick way to view logs no matter where you are in the platform.

To learn more, see the documentation about APM logs in context.
- Add support for logging metrics
  
  Logging metrics show the rate of log messages by severity in the logs chart in the APM Summary view. This is enabled by default in this release.
- Add support for forwarding application logs to New Relic
  
  This automatically sends application logs that have been enriched to power APM logs in context. This is disabled by default in this release. This will be on by default in a future release. For more information, see our documentation about logs in context for Python.
- Add support for enriching application logs written to disk or standard out
  
  This can be used with another log forwarder to power APM logs in context if in-agent log forwarding is not desired. We recommend enabling either log forwarding or local log decorating, but not both features. This is disabled by default in this release.

Changes

Rename Whitelist Setting to Allowlist

The setting strip_exception_messages.whitelist has been renamed to the more modern name strip_exception_messages.allowlist. The original setting will continue to function but issue a deprecation warning.

Bug Fixes

Fix incompatibility with gRPC v4

Previously a crash was possible in the agent when gRPC v4 was installed when not using the infinite tracing feature. This has been corrected and the agent can safely be used with gRPC v4.
Fix Starlette v0.19.1+ instrumentation
- A crash in CustomRoutes in Starlette v0.19.1 has been addressed and fixed.
- Starlette v0.20.1 reorganized important files which were then uninstrumented. This has been fixed.
Fix unhelpful error messages appearing outside of debug logs

Error messages related to context propagation have been demoted to debug logs to avoid unwanted and unhelpful messages appearing in logs.

Python agent v8.2.1

Mon, 10 Oct 2022 00:00:00 +0000

Notes

This release of the Python agent provides numerous bug fixes, including several community contributions, provides updates to Sanic instrumentation, Protobuf v4 compatiblity, and updates internal packages for Python 3.11 support.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Version numbering change

The version number of the agent did not previously follow Semantic Versioning properly. This has been changed. Going forward build numbers have been removed from the version number, and version increments will follow semantic versioning fully. No retroactive changes will be made to previous version numbers.

Instrumentation updates

Update Sanic middleware support

Sanic recently changed their APIs surrounding middleware, and instrumentation has been updated to support it.

Package updates

Update wrapt to v1.14.1

The internal copy of the wrapt library used by the agent has been updated to v1.14.1 for Python 3.11 compatibility.
Add support for Protobuf v4

The agent is now fully compatible with Protobuf v4 when using Infinite Tracing. Backwards compatibility with Protobuf v3 has been preserved.

Bug fixes

Fix a RuntimeError in the trace cache when using the coroutine profiler

A RuntimeError occurred if traces were started or stopped while the coroutine profiler was sampling the active traces. This should no longer be possible.

Thank you @lovmat for your contribution!
Fix an issue with case sensitivity in record-deploy

Previously application names were incorrectly being treated as case-sensitive when running newrelic-admin record-deploy.

Thank you @michalborkowski96 for your contribution!
Fix an issue with newer installers failing to install the agent

Due to the inclusion of both scripts and entry_points configuration options, the agent would fail to install with newer installers. This has been corrected and newer PEP compliant installers should have no trouble installing the agent.

Thank you @admp-fh for your contribution!
Fix instrumentation for aioredis interfering with transactions

The agent does not currently support transactions for Redis clients, and previous instrumentation broke transaction functionality in AioRedis. This has been fixed to provide no instrumentation within transactions at this time.
Fix a crash when completing various kinds of traces inside a stopped transaction

Previously certain types of traces could throw exceptions and fail to complete when inside stopped transactions. This has been corrected and should no longer be possible.
Fix a bug where instrumentation caused certain arguments to confluent-kafka producers to stop working

Previously callback and on_delivery arguments were passed through improperly leading to them not working as expected.

Support statement

New Relic recommends that you upgrade the agent regularly and at a minimum every 3 months. As of this release, the oldest supported version is 5.2.2.130. More information can be found in the EOL Policy Page.

Python agent v8.1.0.180

Mon, 12 Sep 2022 00:00:00 +0000

Notes

This release of the Python agent adds automatic instrumentation for Hypercorn, and includes bug fixes for Sanic v21.9+, memory sampler reporting, and database traces.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add Hypercorn instrumentation

Instrumentation has been added for Hypercorn, an ASGI web server.

Bug fixes

Fix instrumentation for Sanic v21.9+

Instrumentation for newer versions of Sanic (>=21.9) have either not reported data or crashed due to an incompatibility with Sanic's internal metaprogramming.
Fix incorrect PID reported by memory sampler

The PID reported by the memory sampler when sampling processes was incorrectly attributed to the process the agent was initialized from.
Fix issue with database traces causing crashes

In rare instances a database trace could result in a setting not being found, causing a crash.

Support statement

New Relic recommends that you upgrade the agent regularly and at a minimum every 3 months. As of this release, the oldest supported version is 5.2.0.127.

Python agent v8.0.0.179

Mon, 15 Aug 2022 00:00:00 +0000

Notes

This release of the Python agent removes support for Python 3.6. It also includes new instrumentation for Daphne, reporting installed module versions, and a fix for a bug affecting Loguru file paths.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Deprecations

Removed support for Python 3.6

Python 3.6 is no longer supported by the agent. Please consider upgrading your application to a supported version of Python in order to continue to receive updates to the Python Agent.

New features

Add Daphne instrumentation

Instrumentation has been added for Daphne, a Django project ASGI web server and the recommended server for Django Channels.
Add module version reporting

Installed python packages now have their versions reported and are visible in the Environment tab for your application in New Relic One.

Bug fixes

Fix a bug in file path detection for Loguru

Wrappers from the agent interfered with Loguru file path detection for templating messages. This has been corrected on all versions. Thank you to @rafaelclp for your contribution!

Support statement

New Relic recommends that you upgrade the agent regularly and at a minimum every 3 months. As of this release, the oldest supported version is 5.0.2.126.

Python agent v8.2.0.181

Tue, 27 Sep 2022 00:00:00 +0000

Notes

This release of the Python agent adds automatic instrumentation for Kafka Python as well as Confluent Kafka.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add kafka-python instrumentation

Instrumentation has been added for Kafka Python.
Add confluent-kafka instrumentation

Instrumentation has been added for Confluent Kafka.

More information can be found in the Message Queue documentation

Support statement

New Relic recommends that you upgrade the agent regularly and at a minimum every 3 months. As of this release, the oldest supported version is 5.2.0.127. More information can be found in the EOL Policy Page.

Python agent v8.3.0

Mon, 24 Oct 2022 00:00:00 +0000

Notes

This release of the Python agent adds Python 3.11 support, deprecates the add_custom_parameter(s) API, adds usage metrics for multiple libraries, and includes bug fixes.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Deprecations

add_custom_parameter(s) API is now deprecated The add_custom_parameter(s) API has been renamed to add_custom_attribute(s). A deprecation warning will be emitted when calling add_custom_parameter() from this agent version and higher.

New features

Add support for Python 3.11 The agent now supports applications running in Python 3.11.
Add usage metrics for Kafka clients, Daphne, and Hypercorn The agent now emits a messagebroker metric for Kafka clients and a dispatcher metric for Daphne and Hypercorn. This metric is similar to the framework metric already being emitted for all web frameworks supported by the agent.

Bug fixes

Fix Flask view support for Code Level Metrics The agent was previously reporting the class name for the code.function attribute in the case of Flask method dispatching. This has been corrected to report the instrumented function name.
Fix aioredis version crash A fix has been implemented to address a crash in aioredis in cases where the agent was initialized before importing aioredis on aioredis>=2.0.1.

Support statement

Python agent v8.4.0

Wed, 26 Oct 2022 00:00:00 +0000

We recommend updating to the latest agent version as soon as it's available. If your organization has established practices that prevent you from upgrading to the latest version, ensure that your agents are regularly updated to a version at most 90 days old. Read more about keeping your agent up to date.

As of this release, the oldest supported version is 5.2.2.130.

Notes

This release of the Python agent increases the custom event limit and includes a bug fix.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Changes

Increase custom event limit

This agent version increases the default limit of custom events from 1,200 events per minute to 3,600 events per minute. In the scenario that custom events were being limited, this change will allow more custom events to be sent to New Relic. There is also a new configurable maximum limit of 100,000 events per minute. To change the limits, see the docs for event_harvest. To learn more about the change and how to determine if custom events are being dropped, see our Explorers Hub post.

Bug fixes

Fix NewRelicContextFormatter attribute error

A bug was introduced in v8.3.0 that caused an AttributeError when using the NewRelicContextFormatter. This has been corrected in this release version.

Python agent v8.6.0

Thu, 09 Feb 2023 00:00:00 +0000

Notes

This release of the Python agent adds support for elasticsearch 8, redis.asyncio, and exposes apdexPerfZone.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for eleasicsearch 8 Add instrumentation support for elasticsearch version 8.
Add support for redis v4.4.1 and v4.4.2 Add support for new methods in the latest versions of redis.
Add support for redis.asyncio aioredis is included to redis-py since version 4.2.0rc1 as redis.asyncio. Support this new location. Thank you @pauk-slon for your contribution!
Add apdexPerfZone to web transaction event attribute intrinsics Expose nr.apdexPerfZone as apdexPerfZone in Web transaction event attribute intrinsics.

Support statement

New Relic recommends that you upgrade the agent regularly and at a minimum every 3 months. As of this release, the oldest supported version is 5.6.0.135. More information can be found in the EOL Policy Page.

Python agent v8.5.0

Wed, 07 Dec 2022 00:00:00 +0000

Notes

This release of the Python agent adds the record_log_event API and includes some bug fixes.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for redis v4.3.5 and v4.4.0 methods

New methods added in redis v4.3.5 and v4.4.0 will now be automatically instrumented.
Add record_log_event API

This records a log event that can be viewed and queried in the New Relic UI. See record_log_event for details.

Bug fixes

Fix RuntimeError: dictionary changed size during iteration

Properly guard trace_cache from RuntimeErrors raised due to concurrent iteration and size changes of the TraceCache.
Fix confluent-kafka producer arguments

Fixes a bug where topic provided as a keyword argument can crash Confluent Kafka producers.
Patch sentry SDK to correct ASGI v2/v3 detection

Patches sentry-sdk to fix a bug that causes incorrect ASGI application version detection with our wrapt function wrappers. To fix this, we now instrument the _looks_like_asgi3() function to bind out the wrapped app in sentry in order to unwrap it to be able to detect the proper ASGI version.
Fix missing information issue with Celery workers when using MAX_TASKS_PER_CHILD

A bug was introduced in v7.8.0.174 when Celery was run with the --loglevel=INFO flag to not report any data after the original worker processes shut down. This has been fixed.
Fix support for dynamically generated types in Code Level Metrics

A bug in code level metrics attribute extraction prevented attributes from being applied to types created using the 3 argument type constructor. This has been fixed.
Fix external node properties initialization

A bug caused by uninitialized external node properties when making web requests has been fixed. Thank you @kmorey for your contribution!

Support statement

New Relic recommends that you upgrade the agent regularly and at a minimum every 3 months. As of this release, the oldest supported version is 5.4.1.134. More information can be found in the EOL Policy Page.

Python agent v8.7.0

Thu, 16 Feb 2023 00:00:00 +0000

Notes

This release of the Python agent adds support for batching and compression.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support batching and compression of infinite tracing

Adds configuration options infinite_tracing.compression and infinite_tracing.batching and sets both to on by default.

Support statement

New Relic recommends that you upgrade the agent regularly and at a minimum every 3 months. As of this release, the oldest supported version is 5.8.0.136. Find more information in the EOL Policy Page.

Python agent v8.7.1

Mon, 20 Mar 2023 00:00:00 +0000

Notes

This release of the Python agent adds support for a new config option to capture GraphQL introspection query transactions.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for a new config option to capture GraphQL introspection query transactions.

Added new config setting instrumentation.graphql.capture_introspection_queries and corresponding environment variable NEW_RELIC_INSTRUMENTATION_GRAPHQL_CAPTURE_INTROSPECTION_QUERIES to control capturing of GraphQL introspection transactions. Defaults to false which retains previous behavior of ignoring transactions with introspection queries.

Bug fixes

Fix introspection query recognition for GraphQL.

Fix introspection query recognition for GraphQL to allow introspection fields to be queried alongside real fields in traces.

Support statement

New Relic recommends that you upgrade the agent regularly and at a minimum every 3 months. As of this release, the oldest supported version is 5.12.0.140. Find more information in the EOL Policy Page.

Python agent v8.8.1

Mon, 26 Jun 2023 00:00:00 +0000

Notes

This release of the Python agent fixes a bug in package reporting and adds support for redis 4.6.0 and loguru 0.7.0.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Enhancements

Add support for redis 4.6.0 Adds instrumentation support for new waitaof method.
Add support for loguru 0.7.0 Adds support for loguru v0.7.0.

Bug fixes

Fix reporting of locally scoped packages Previously, locally scoped Python packages (such as those installed into user scope) were not reported on agent connect. This has been fixed.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v8.9.0

Thu, 27 Jul 2023 00:00:00 +0000

Notes

This release of the Python agent adds support for RedisCluster.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Enhancements

Add support for RedisCluster Adds instrumentation support for RedisCluster.

Bug fixes

Resilient Environment Settings Fixed a crash when using generalimport with the agent. Thanks for the contribution, aaeabdo!
Remove deprecated drop_transaction calls from agent The drop_transaction function had been removed from the agent but references to it still existed, so this version of the agent removes any remaining calls.
Fix logic in serverless distributed tracing to work by default

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v8.8.0

Thu, 30 Mar 2023 00:00:00 +0000

Notes

This release of the Python agent adds support for two new errors inbox features: error fingerprinting and user tracking. It also includes bug fixes.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

New Errors Inbox features

User tracking: You can now see the number of users impacted by an error group. Identify the end user with the set_user_id method.

Error fingerprinting: Are your error occurrences grouped poorly? Set your own error fingerprint via a callback function.

Bug fixes

Guard GraphQL settings lookup In v8.7.1, a bug was introduced in GraphQL instrumentation when not running within a transaction. This crash has been addressed.
Fix Redis instance information Redis v4.5.2 included a change that broke detection for socket based redis instance information. The agent now correctly detects socket paths again.

Support statement

New Relic recommends that you upgrade the agent regularly and at a minimum every 3 months. As of this release, the oldest supported version is 5.12.0.140. More information can be found in the EOL Policy Page.

Python agent v8.10.0

Thu, 10 Aug 2023 00:00:00 +0000

Notes

This release of the Python agent drops support for Redis v3 and below and adds support for Google Cloud Firestore, async Redis, and fixes a crash that occurs when wrapping generators.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Deprecations

Drop support for Redis v3 and below As of v8.10.0, Redis v3 and below are outside New Relic's supportability window and therefore no longer supported. Because Redis v4 and above no longer support Python 2.7, this means Python 2.7 support has been dropped from Redis as well.

Enhancements

Add support for Firestore Adds instrumentation support for Google Cloud Firestore.
Add support to Redis Async Adds instrumentation support for Redis' async features. Thanks, ahmedhr and bc291 for your contribution!
Automatic wrapping for async generators Existing tracing decorator APIs now support async generators out of the box.

Bug fixes

Fixed a crash when consecutive calls to throw() on wrapped generators Previously consecutive calls to throw() would raise an exception rather than inject the exception into the wrapped generator.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v8.10.1

Thu, 17 Aug 2023 00:00:00 +0000

Notes

This release of the Python agent fixes an issue with MetricNormalizationRules, fixes a DeprecationWarning in package version detection, and adds support for new commands introduced in Redis v5.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Enhancements

Add support for new commands introduced in Redis v5 Adds full instrumentation support for Redis v5.

Bug fixes

Fix crash in MetricNormalizationRules Fixed a crash when using client side MetricNormalizationRules to ignore metrics (set through NerdGraph and available under a feature flag). The metrics should now be properly ignored.
Fix DeprecationWarning in package version detection for Python 3.10+ Fixed a DeprecationWarning emitted by package version detection used internally for Python 3.10+. When importlib.metadata is available, prefer using it to avoid checking deprecated version attributes on modules. (Thanks @renanivo for the contribution!)

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v8.11.0

Wed, 23 Aug 2023 00:00:00 +0000

Notes

This release of the Python agent adds support for structlog and some bug fixes.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Enhancements

Add support for structlog Adds instrumentation support for structlog.

Bug fixes

Fix certificate fallback logic Fixed the fallback logic for the certificate bundle such that it only uses the builtin bundle when both the cafile AND capath are None.
Fix missing database metric Fixed an issue where certain databases were not recording the Datastore/instance/<db>/<host>/<port> metric and so the database was not showing up in the service map.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.0.0

Mon, 28 Aug 2023 00:00:00 +0000

Notes

This release of the Python agent adds support for async graphql-core and drops support for graphql-core 2.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Framework Support

Drop support for graphql-core 2 Remove support for graphql-core 2.0.

Enhancements

Add support for async graphql-core Add support for async graphql-core 3.0 and above.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.1.0

Mon, 25 Sep 2023 00:00:00 +0000

Notes

This release of the Python agent adds support for sklearn and redis.asyncio connections.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for sklearn The Python agent now supports monitoring for machine learning models created with sklearn. Check out our documentation for details on how to view and query for your prediction events and ML related metrics directly in the New Relic user interface. Machine learning instrumentation will be disabled by default in this release. To enable it, visit our configuration page for further information. This release also introduces two new APIs to support customization of machine learning monitoring: wrap_mlmodel and record_ml_event.
Add instrumentation for redis.asyncio.Connection Add instrumentation support for connections initiated from the redis.asyncio module

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.1.1

Thu, 19 Oct 2023 00:00:00 +0000

Notes

This release of the Python agent fixes generator instrumentation issue with Redis and adds caching to package versions to address some performance issues.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add caching to get_package_version to address performance issues

Bug fixes

Fix generator and async generator instrumentation issue in Redis.asyncio

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.1.2

Mon, 13 Nov 2023 00:00:00 +0000

Notes

This release of the Python agent fixes a regression in package version performance that was introduced in 8.10.1.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Bug fixes

Fix package version performance regression Addressed issue that was introduced in 8.10.1 where there is increased CPU usage and time on startup and when using certain libraries at runtime.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.4.0

Mon, 08 Jan 2024 00:00:00 +0000

Notes

This release of the Python agent adds support for nonced content security policies for browser agent injection, adds new wheels for Python 3.12 and musl Linux systems such as Alpine, deprecates the ObjectWrapper and get_browser_timing_footer APIs, fixes a crash with Kafka instrumentation when using distributed tracing, and removes a case sensitive header check in ASGIBrowserMiddleware.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Deprecations

Deprecated newrelic.agent.ObjectWrapper API
- Removes custom newrelic.agent.ObjectWrapper implementation and instead creates a pass through to wrapt.FunctionWrapper.
Deprecated get_browser_timing_footer API
- Previously get_browser_timing_footer was an API that would be used to supply information to the browser agent loaded by get_browser_timing_header.
- This step is now included in get_browser_timing_header, making get_browser_timing_footer obsolete. This function now returns an empty string to avoid breaking existing applications.

New features

Added nonced content security policies (CSPs) for browser agent injection
- The browser agent injection API get_browser_timing_header has a new parameter nonce that takes a cryptographic nonce for use with content security policies. The nonce will be automatically inserted into the generated HTML.
Added additional wheel options for Python 3.12 and musl Linux
- Added pre-built binary wheel support for Python 3.12 as well as alternative wheels for musl-based Linux operating systems (such as Alpine).
Added newrelic.agent.CallableObjectProxy to public APIs
- Previously CallableObjectProxy was never exposed for general use with custom instrumentation, but was present in internal modules used by the agent.
- This API has been added to newrelic.agent.CallableObjectProxy for general use.

Bug fixes

Fixed a crash with kafka-python and confluent-kafka when using distributed tracing
- Previously Kafka instrumentation packages would sometimes fail to generate distributed tracing headers and cause a crash. This has been fixed and distributed tracing headers should now generate correctly.
Removed case sensitive header check in ASGIBrowserMiddleware
- The agent previously only supported HTML insertion for headers that were lowercase in ASGI applications. The header check is now case insensitive in compliance with the ASGI specification.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.3.0

Wed, 06 Dec 2023 00:00:00 +0000

Notes

This release of the Python agent adds Python 3.12 support. It also includes support for sending utilization data for Docker with cgroups v2, adds a new synthetics information header, upgrades the agent's internal wrapt version, and includes a bug fix for structlog.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for Python 3.12 The agent now supports applications running in Python 3.12.
Add support for Docker cgroups v2 The agent now includes functionality to parse Docker IDs in later versions of Docker using cgroups v2.
Add new synthetics information header The agent now retransmits and processes information contained in a new synthetics header: X-NewRelic-Synthetics-Info.

Changes

Upgrade internal wrapt to v1.16.0 The agent's internal copy of wrapt has been upgraded to v1.16.0 in conjunction with Python 3.12 support.

Bug fixes

Fix structlog CallsiteParameter processor bug Call site parameter values in structlog no longer produce incorrect values.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.2.0

Thu, 16 Nov 2023 00:00:00 +0000

Notes

This release of the Python agent adds a new configuration option that allows users to disable capturing package and version information at agent startup.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add new configuration option package_reporting.enabled. This option allows users to disable capturing package and version information at agent startup. On some applications with a high number of packages some users were seeing a spike in CPU usage. Disabling this setting provides a workaround for that issue.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.5.0

Thu, 11 Jan 2024 00:00:00 +0000

Notes

This release of the Python agent adds context data attributes to logs, support for dictionary type log messages, adds attribute support to record_log_event API, and obfuscates logged license keys and user API keys.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add context data attributes to logs
- Context data available from logging frameworks can now be recorded as attributes on logs. These attributes are prefixed with context., which is not considered when filtering attributes from logs.
- Context data may include extras, dictionary message attributes, and attributes provided by logging frameworks.
- To report these attributes, enable context data forwarding and optionally configure include and exclude rules to filter the allowed attributes.
Add support for dictionary type log messages
- Dictionary type log messages are now supported for logging frameworks which support dictionary type log messages (including the builtin logging module and structlog).
- The key message will be extracted if available and treated as the log message, and any other items will be considered context data attributes and prefixed with message.. These attributes are subject to the same filtering rules as other context data.
Add attribute support to record_log_event API
- The record_log_event API now allows passing context data in using the optional attributes keyword argument, and allows the message argument to be a dictionary as described above.
Obfuscate license keys and user API keys in logs
- The agent now obfuscates all instances of license keys or user API keys in agent logs and audit logs.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.7.0

Thu, 22 Feb 2024 00:00:00 +0000

Notes

This release of the Python agent no longer reports attributes with None values. It also attaches a transaction trace ID to the error traces even when distributed tracing is disabled.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Remove reporting of attributes with None values
- Previously, the agent recorded attributes with a value of None type as the string "None". The agent will no longer record user or agent attributes that have None type values.

Bug fixes

Add transaction trace ID to the error traces even when distributed tracing is disabled
- Previously, certain trace attributes in error traces such as stack traces were only visible in the UI if distributed tracing was enabled. Linking the transaction trace to error traces by including the transaction trace ID on the error traces allows the user to have access to the transaction trace attributes in the UI.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.6.0

Thu, 25 Jan 2024 00:00:00 +0000

Notes

This release of the Python agent fixes a bug when specifying processors in structlog, and updates the NewRelicLogForwardingHandler to support dictionary type logs and formatters.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Support dictionary type logs in NewRelicLogForwardingHandler
- Dictionary type log messages are now supported in NewRelicLogForwardingHandler when passed as the log message, or when a custom formatter returns a dictionary.
- The key message will be extracted if available and treated as the log message, and any other items will be considered context data attributes and prefixed with message..
  - These attributes are subject to the same filtering rules as other context data. The message. prefix is not considered when filtering attributes from logs.
  - To report these attributes, enable context data forwarding and optionally configure include and exclude rules to filter the allowed attributes.
Support logging formatters in NewRelicLogForwardingHandler
- Logging formatters added with setFormatter() are now supported, and may return a string or dicitionary log message type to be forwarded to New Relic.

Bug fixes

Fix a bug when specifying processors in structlog
- Previously, there was a bug in the structlog instrumentation where processors was assumed to be list type. Now the instrumentation supports processors of all iterable types.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.8.0

Wed, 27 Mar 2024 00:00:00 +0000

Notes

This release of the Python agent adds support for the latest versions of asgiref and support for AI monitoring when using the following libraries: OpenAI, AWS Bedrock, and Langchain.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add support for asgiref 3.8.0 and above
- Asgiref released a new version that resulted in missing transaction context. This has been fixed.
AI monitoring
- New Relic AI monitoring is the industry’s first APM solution that provides end-to-end visibility for AI Large Language Model (LLM) applications. It enables end-to-end visibility into the key components of an AI LLM application. With AI monitoring, users can monitor, alert, and debug AI-powered applications for reliability, latency, performance, security and cost. AI monitoring also enables AI/LLM specific insights (metrics, events, logs and traces) which can easily integrate to build advanced guardrails for enterprise security, privacy and compliance.
- AI monitoring offers custom-built insights and tracing for the complete lifecycle of an LLM’s prompts and responses, from raw user input to repaired/polished responses. AI monitoring provides built-in integrations with popular LLMs and components of the AI development stack. This release provides instrumentation for OpenAI, AWS Bedrock, and Langchain.
- When AI monitoring is enabled with ai_monitoring.enabled = true, the agent will now capture AI LLM related data. This data will be visible under a new APM tab called AI Responses. See our AI Monitoring documentation for more details.
AI monitoring configuration
- New configuration options are available specific to AI monitoring. These settings include:
  - ai_monitoring.enabled
  - ai_monitoring.streaming.enabled
  - ai_monitoring.content.enabled
AI monitoring public API methods
- Two new AI monitoring related public API methods have been added:
  - record_llm_feedback_event
  - set_llm_token_count_callback
Add support for AWS Bedrock
- Support for AWS Bedrock Large Language Model instrumentation has been added. Chat completion and embedding data for streaming and non-streaming is recorded for the following models:
  - amazon.titan-*
  - ai21.j2-*
  - anthropic.claude-*
  - cohere.command-*
  - meta.llama2-*
  - amazon.titan-embed*
  - cohere.embed*
Add support for Langchain
- Support for Langchain Large Language Model instrumentation has been added. Langchain Agents, Chains, Tools, OpenAI, and Bedrock LLM data is recorded. Note streaming is not supported at this time.
Add support for OpenAI
- Support for OpenAI Large Language Model instrumentation has been added. Synchronous and asynchronous chat completion and embedding data is recorded. Note streaming is only supported in chat completions at this time.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.9.1

Mon, 13 May 2024 00:00:00 +0000

Notes

This release of the Python agent fixes Celery instrumentation on worker processes, adds new Langchain vectorstores, adds HTTP method attributes to urllib3 traces, and fixes an issue with URI detection in gRPC clients.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add new Langchain vectorstores
- Support for the following Langchain vectorstores: Relyt, OracleVS, UpstashVectorStore, VLite

Bug fixes

Fix Celery instrumentation on worker processes
- Instrumentation updates in v9.9.0 introduced a bug where Celery workers running with worker optimizations enabled would overwrite instrumentation. This has been fixed and instrumentation should now function the same with and without worker optimizations enabled.
Add HTTP method attributes to urllib3 traces
- urllib3 traces did not include the HTTP method as an attribute previously. This has now been added.
Fix gRPC URI detection for client ExternalTraces
- The latest version of gRPC changed the format of URIs used in clients, which caused the hostname to be reported as "dns" for all client requests. This has been fixed and hostnames should be reported correctly again.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.10.0

Thu, 23 May 2024 00:00:00 +0000

Notes

This release of the Python agent:

Adds instrumentation for AIOBotocore
Adds support for Meta Llama3 and Mistral AI in
Amazon Bedrock
Fixes an error parsing issue in OpenAI
Updates Loguru's instrumentation to use milliseconds instead of seconds

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add AIOBotocore instrumentation
- Add instrumentation for AIOBotocore. Supports proxy mode in addition to standard operation.
Add new
Amazon Bedrock
models
- Add instrumentation for the following
  Amazon Bedrock
  models:
  - Meta Llama3
  - Mistral AI

Bug fixes

Fix OpenAI error parsing
- Previously, if an error in OpenAI was encountered, the Python Agent would attempt to override the default error.message within notice_error() with the one used in OpenAI. However, if there was no message attribute in the error, the Python Agent would crash. Now it defaults to the original methodology of error handling by the Python Agent.
Record timing in Loguru in milliseconds
- Timing in Loguru is recorded as an integer and if that value was less than 1 second, it would record it as 0s. This changes the units to be in milliseconds instead. Thanks, (@julia-tadej-wwtech)[https://github.com/julia-tadej-wttech] for the contribution!

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.9.0

Thu, 18 Apr 2024 00:00:00 +0000

Notes

This release of the Python agent updates Celery instrumentation, adds new Langchain vectorstores, adds configuration to capture memory usage runtime metrics per process, fixes a content reporting issue in Anthropic Claude, and upgrades internal version of urllib3 to v1.26.18.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Security

Upgrade internal version of urllib3 to v1.26.18
- Upgrade the internal version of urllib3 used in the Python Agent to v1.26.18 to resolve security warnings.

New features

Update Celery instrumentation
- Add support for distributed tracing in Celery over AMQP headers.
- Remove duplicate function traces for some methods of running tasks.
  - All tasks should now only be instrumented once, and will report either an OtherTransaction, or a FunctionTrace if run under an existing transaction.
- Fix instrumentation for grouped celery tasks APIs, such as task.map(), celery.group(), and celery.chunks().
  - Tasks run using task.map() or task.starmap() will now name tasks in the format Celery/celery.map/my_task to allow you to differentiate between map tasks.
  - Individual task runs created by the map() and starmap() tasks will be traced with a FunctionTrace to capture individual timings.
Add new Langchain vectorstores
- Support for the following Langchain vectorstores: DuckDB, EcloudESVectorStore, InMemoryVectorStore, PathwayVectorClient, VDMS
Add configuration setting to enable capturing of memory usage runtime metrics per process
- Add memory_runtime_pid_metrics.enabled configuration setting to toggle capturing of memory usage metrics (per process ID only) to reduce Metric Grouping Issues (MGI).

Bug fixes

Report only raw content dictionary for Anthropic Claude
- Previously, AWS Bedrock's Anthropic Claude model would report a list of dictionaries of message content. Now it reports a single dictionary of message content.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.11.0

Thu, 13 Jun 2024 00:00:00 +0000

Notes

This release of the Python agent adds agent_language to lambda metadata, support for injecting the agent into Kubernetes, support for psycopg 3.0+, optimizes plugins list capturing, fixes the Large Language Model event duration units, a crash in ASGI when the Content-Length header is missing, a crash when using OpenAI's .with_raw_response. and .with_streaming_response..

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add agent_language to lambda metadata
- Add agent_language to collected lambda metadata.
Optimize plugins list capturing
- Skip checking for a package version on newrelic hooks that we know do not have versions.
Add support for injecting the agent into Kubernetes
- Updates the bootstrap sitecustomize file to support injecting the agent into a Kubernetes cluster.
- A full product for agent injection in Kubernetes will be coming soon in public preview.
- A new informational only setting called k8s_operator.enabled (with NEW_RELIC_K8S_OPERATOR_ENABLED as an environment variable) was added, which is used to report when the agent is injected into a Kubernetes cluster. This setting does not enable/disable this function of the agent.
Add support for psycopg 3.0+
- New instrumentation for psycopg 3.0+ has been added, providing database tracing for both the Connection and AsyncConnection classes.

Bug fixes

Fix Large Language Model event duration units
- Previously, durations on LLM events were recorded in seconds which did not match some of the other language agents. This has been changed to be milliseconds.
Fix crash when using OpenAI's .with_raw_response.
- Previously, an exception would be raised inside the instrumentation when .with_raw_response. was used. This no longer happens, the instrumentation successfuly records LLM data when .with_raw_response. is used.
Fix crash when using OpenAI's .with_streaming_response.
- Previously, an exception would be raised inside the instrumentation when .with_streaming_response. was used. This no longer happens, the instrumentation is just skipped.
Fix a crash in ASGI when the Content-Length header is missing
- Previously, an exception would be raised inside the instrumentation that injects the browser agent when an ASGI response was missing the Content-Length header. This issue has been fixed.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.7.1

Mon, 11 Mar 2024 00:00:00 +0000

Notes

This release of the Python agent fixes a bug in the NewRelicContextFormatter where attributes were dropped from logs.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

Bug fixes

Fix log attribute dropping in NewRelicContextFormatter
- In v9.5.0, a bug in the NewRelicContextFormatter was introduced where message was added to the default set of keys to exclude. This caused extra attributes not in the default list to be dropped. This bug has been fixed.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.12.0

Thu, 11 Jul 2024 00:00:00 +0000

Notes

This release of the Python agent adds instrumentation for aiomcache, support for an internally set collect_ai serverside configuration setting, formatting stack traces in NewRelicContextFormatter, fixes a crash in package catpuring in Python 2.7, an attribute check in OpenAI instrumentation, and casing on LangChain metric and span names.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add instrumentation for aiomcache:
- Add instrumentation support for aiomcache. Thank you Jair Henrique for the contribution!
Add support for collect_ai serverside config:
- Add support for an internally set collect_ai serverside configuration setting. Note this is returned in the connect response when a particular feature flag is set on an account.
Adds support for formatting stack traces in NewRelicContextFormatter:
- NewRelicContextFormatter now implements the format_exc_info class method that formats stack traces. Thank you Daniel Fritz for the contribution!

Bug fixes

Fix crash in package capture in Python 2.7:
- Previously, when capturing packages on Python 2.7 an UnboundLocalError would be raised. This has been fixed.
Fix attribute check in OpenAI:
- Fix a typo in an attribute check inside the OpenAI instrumentation. Thank you Liam Niehus-Staab for the contribution!
Fix casing on LangChain metric and span names:
- Previously, if LangChain was being used in combination with an unsupported Large Language Model library (aka not Bedrock or OpenAI) then the AI dashboard tab would not appear in the UI because the metric name was not cased correctly. This has been fixed and the Span names have been updated to match the casing of the metric name.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v9.13.0

Thu, 08 Aug 2024 00:00:00 +0000

Notes

This release of the Python agent adds the following:

Support for boto3's upload_file command
Support for newly added Redis commands
AWS SQS information on spans
server.address attribute on RabbitMQ

This release also fixes an issue with OpenAI's client instrumentation and missing parameters in Botocore SQS.

Install the agent using easy_install/pip/distribute via the Python Package Index or download it directly from the New Relic download site.

New features

Add instrumentation for upload_file in boto3
- Add instrumentation to the s3transfer BoundExecutor submit function, allowing the agent to support the upload_file operation in boto3.
Add support for new Redis commands
- Add instrumentation for the following commands in Redis:
  - hexpire
  - hexpireat
  - hexpiretime
  - hpersist
  - hpexpire
  - hpexpireat
  - hpexpiretime
  - hpttl
  - httl
Capture AWS SQS information on message spans:
- The Python Agent now captures the following AWS SQS information on message spans, allowing the UI to link AWS information with AWS SQS:
  - messaging.system - aws_sqs
  - cloud.region - AWS region
  - cloud.account.id - AWS account ID
  - messaging.destination.name - AWS queue name
Add server.address attribute to RabbitMQ:
- Add server.address attribute to RabbitMQ, allowing the UI to link AWS information with AWS MQ.

Bug fixes

Fix TypeError in OpenAI instrumentation:
- Newer versions of OpenAI include an additional argument, resulting in an error with the base client instrumentation. This has been fixed.
Fix missing parameters in MessageTrace:
- Resolved issue where parameters were not being passed from the MessageTraceWrapper to the MessageTrace.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.

Python agent v12.0.0

Thu, 12 Mar 2026 00:00:00 +0000

Notes

This release of the Python agent removes support for Cross Application Tracing (CAT), Python 3.8, and the bundled SSL certificates. It also updates all vendored packages to their latest versions, and adds support for free-threaded CPython, Windows operating systems, and improved instrumentation for Microsoft AG2 (Autogen). Additionally, this release includes a new optional extra for installing SSL certificates through certifi. This release also fixes a bug in Strands Agents instrumentation which caused duplicate exceptions to be reported.

Install the agent using easy_install/pip/distribute via the Python Package Index, using conda via the Conda-Forge Package Index, or download it directly from the New Relic download site.

Removed features

Cross Application Tracing (CAT) has been removed in favor of Distributed Tracing (DT).
- Cross Application Tracing (CAT) was deprecated in agent version 7.0.0.166, and has been removed in this release. If you are still using Cross Application Tracing (CAT), we recommend migrating to Distributed Tracing (DT) as soon as possible to avoid disruption.
The bundled SSL certificates have been removed.
- If you require certificates for your environment, you can either install them via your operating system's package manager or install the agent with the optional newrelic[certificates] extra.
Python 3.8 support has been removed.
- Python 3.8 reached End-of-Life on 2024-10-07 and is no longer supported by the agent. Please consider upgrading your application to a supported version of Python in order to continue to receive updates to the Python Agent.

Security

All internal packages updated to their latest versions.
- urllib3 updated to v2.6.3
  - This fixes all open CVEs on urllib3 as of the date of this release.
- opentelemetry_proto updated to v1.40.0
- wrapt updated to v2.1.2
- asgiref updated to v3.11.1

New features

New newrelic[certificates] extra for installing SSL certificates through certifi.
- The agent now provides an optional newrelic[certificates] extra which can be used to install the bundled SSL certificates. This is intended for users who require certificates but are unable to install them via their operating system's package manager.
Free-Threaded CPython support
- Starting with Python 3.13, CPython releases builds of Python with the Global Interpreter Lock (GIL) disabled, allowing for true multi-threading.
- This release adds support for this behavior, allowing the agent to safely run in a free-threaded environment.
- This release also includes pre-built binaries for free-threaded CPython on Linux and Windows, allowing for easy installation in these environments.
Windows Support
- This release includes pre-built binaries for CPython 3.13 or higher on Windows.
- Note that Python 3.12 or lower is not officially supported on Windows due to large variances in the resolution of timers. It's still possible to install and use the agent from source, but users may experience issues with inaccurate timing data and should upgrade to Python 3.13 or higher for the best experience.
Improved instrumentation for Microsoft AG2 (Autogen)
- Added support for streaming responses through the asynchronous generator method on_messages_stream().
- Instrumentation now includes a subcomponent attribute on spans that represent tool or agent calls. This is used to provide more enhanced entity mapping in the New Relic UI.

Bugs

Duplicate exceptions in Strands Agents
- After an update to Strands Agents which encapsulates some exceptions in a new EventLoopException type, duplicate errors could be reported. This has been fixed and the underlying error should only be reported once.

Support statement

See the New Relic Python agent EOL policy for information about agent releases and support dates.