Changelogs » Mr.poe

PyUp Safety actively tracks 262,358 Python packages for vulnerabilities and notifies you when to upgrade.



version 3 of the protocol.
  Support includes:
  * Sending 'python' as the platform.
  * The 'tags' option (on all constructors that support options).
  * Updated authentication header.
  Additionally, the following has changed:
  * Configuring the client with an empty DSN value will disable sending of messages.
  * All clients should now check ``Client.is_enabled()`` to verify if they should send data.
  * ``Client.create_from_text`` and ``Client.create_from_exception`` have been removed.
  * ``Client.message`` and ``Client.exception`` have been removed.
  * The ``key`` setting has been removed.
  * The ``DEBUG`` setting in Django no longer disables Raven.
  * The ``register_signals`` option in RAVEN_CONFIG (Django) is no longer used.
  * A new helper, ``Client.context()`` is now available for scoping options.
  * ``Client.captureExceptions`` is now deprecated in favor of ``Client.context``.
  * Credit card values will now be sanitized with the default processors.
  * A new eventlet+http transport exists.
  * A new threaded+http transport exists.
  * PyPy is now supported.
  * Django 1.5 should now be supported (experimental).
  * Gevent 1.0 should now be supported (experimental).
  * Python 2.5 is no longer supported.
  * [Django] The ``skip_sentry`` attribute is no longer supported. A new option config option has replaced this: ``SENTRY_IGNORE_EXCEPTIONS``.




  * New serializers exist (and can be registered) against Raven. See ``raven.utils.serializer`` for more information.
  * You can now pass ``tags`` to the ``capture`` method. This will require a Sentry server compatible with the new
  tags protocol.
  * A new gevent+http transport exists.
  * A new tornado+http transport exists.
  * A new twisted+http transport exists.
  * Zope integration has been added. See docs for more information.
  * PasteDeploy integration has been added. See docs for more information.
  * A Django endpoint now exists for proxying requests to Sentry. See ``raven.contrib.django.views`` for more information.


  * Signatures are no longer sent with messages. This requires the server version to be at least 4.4.6.
  * Several fixes and additions were added to the Django report view.
  * ``long`` types are now handled in transform().
  * Improved integration with Celery (and django-celery) for capturing errors.


  * There is now a builtin view as part of the Django integration for sending events server-side
  (from the client) to Sentry. The view is currently undocumented, but is available as ``{% url raven-report %}``
  and will use your server side credentials. To use this view you'd simply swap out the servers configuration in
  raven-js and point it to the given URL.
  * A new middleware for ZeroRPC now exists.
  * A new protocol for registering transports now exists.
  * Corrected some behavior in the UDP transport.
  * Celery signals are now connected by default within the Django integration.


  * The password sanitizer will now attempt to sanitize key=value pairs within strings (such as the querystring).
  * Two new santiziers were added: RemoveStackLocalsProcessor and RemovePostDataProcessor


  * Stacks must now be passed as a list of tuples (frame, lineno) rather than a list of frames. This
  includes calls to logging (extra={'stack': []}), as well as explicit client calls (capture(stack=[])).
  This corrects some issues (mostly in tracebacks) with the wrong lineno being reported for a frame.


  * Raven now tracks the state of the Sentry server. If it receives an error, it will slow down
  requests to the server (by passing them into a named logger, sentry.errors), and increasingly
  delay the next try with repeated failures, up to about a minute.


  * gunicorn is now disabled in default logging configuration


  * Moved exception and message methods to capture{Exception,Message}.
  * Added captureQuery method.


  * Corrected duplicate DSN behavior in Django client.


  * Django can now be configured by setting SENTRY_DSN.
  * Improve logging for send_remote failures (and correct issue created when
  send_encoded was introduced).
  * Renamed SantizePassworsProcessor to SanitizePassworsProcessor.


  * Support sending the culprit with logging messages as part of extra.


  * Added client.exception and client.message shortcuts.


  * Refactored client send API to be more easily extensible.


  * Gracefully handle exceptions in Django client when using integrated
  * Added Client.error_logger as a new logger instance that points to


  * Corrected behavior with raven logging errors to send_remote
  which could potentially cause a very large backlog to Sentry
  when it should just log to ``sentry.errors``.
  * Ensure the ``site`` argument is sent to the server.


  * Made DSN a first-class citizen throughout Raven.
  * Added a Pylons-specific WSGI middleware.
  * Improved the generic WSGI middleware to capture HTTP information.
  * Improved logging and logbook handlers.


  * Corrected logging stack behavior so that it doesnt capture raven+logging
  extensions are part of the frames.


  * Remove logging attr magic.


  * Correct encoding behavior on bool and float types.


  * Fix 'request' attribute on Django logging.


  * Corrected logging behavior with extra data to match pre 1.x behavior.


  * Handle frames that are missing f_globals and f_locals.
  * Stricter conversion of int and boolean values.
  * Handle invalid sources for templates in Django.


  * varmap was refactored to send keys back to callbacks.
  * SanitizePasswordProcessor now handles http data.


  * Renaming raven2 to raven as it causes too many issues.


  * Corrected a bug in setup_logging.
  * Raven now sends "sentry_version" header which is the expected
  server version.


  * Handle more edge cases on stack iteration.


  * Gracefully handle invalid f_locals.


  * All datetimes are assumed to be utcnow() as of Sentry 2.0.0-RC5


  * Now only works with Sentry>=2.0.0 server.
  * Raven is now listed as raven2 on PyPi.


  * raven.contrib.celery is now useable.
  * raven.contrib.django.celery is now useable.
  * Fixed a bug with request.raw_post_data buffering in Django.


  * Servers would stop iterating after the first successful post which was not the
  intended behavior.


  * You can now explicitly pass a list of frame objects to the process method.


  * The default logging handler (SentryHandler) will now accept a set of kwargs to instantiate
  a new client with (GH-10).
  * Fixed a bug with checksum generation when module or function were missing (GH-9).


  * Added a Django-specific WSGI middleware.


  * Two minor fixes for the Django client:
  * Ensure the __sentry__ key exists in data in (GH-8).
  * properly set kwargs['data'] to an empty list when its a NoneType (GH-6).


  * Require ``servers`` on base Client.
  * Added support for the ``site`` option in Client.
  * Moved raven.contrib.django.logging to raven.contrib.django.handlers.


  * Fixed an infinite loop in iter_tb.


  * Removed the ``thrashed`` key in ``request.sentry`` for the Django integration.
  * Changed the logging handler to correctly inherit old-style classes (GH-1).
  * Added a ``client`` argument to ``raven.contrib.django.models.get_client()``.


  * auto_log_stacks now works with create_from_text
  * added Client.get_ident


  * Initial version of Raven (extracted from django-sentry 1.12.1).