KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #developer-tools #ai-agent #claude-code #codex #typescript #ai-agents #deepseek-harness #mcp #cli #rust

honeybadger-python

★ 22 Open GitHub ↗

Send Python and Django errors to Honeybadger.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Honeybadger for Python
![Test](https://github.com/honeybadger-io/honeybadger-python/workflows/Test/badge.svg)

When any uncaught exceptions occur, Honeybadger will send the data off to the Honeybadger server specified in your environment.

## Supported Versions

Tested with Python 3.x against Django latest and LTS releases as well as Flask 1.0 and 1.1.

## Getting Started

Honeybadger for Python works out of the box with Django with only a few configuration options required. The following is a basic setup - more advanced setup will be described later.

### Install Honeybadger

Install honeybadger with pip.

`$ pip install honeybadger`

**Note:** Honeybadger does *not* report errors in `development` and `test`
environments by default. To enable reporting in development environments, see
the `force_report_data` setting.

### Django

In a Django application, add the Honeybadger Django middleware to *the top* of your `MIDDLEWARE` config variable:

```python
MIDDLEWARE = [
  'honeybadger.contrib.DjangoHoneybadgerMiddleware',
  ...
]
```

It's important that the Honeybadger middleware is at the top, so that it wraps the entire request process, including all other middlewares.

You'll also need to add a new `HONEYBADGER` config variable to your `settings.py` to specify your API key:

```python
HONEYBADGER = {
  'API_KEY': '{{PROJECT_API_KEY}}'
}
```

### Flask

A Flask extension is available for initializing and configuring Honeybadger: `honeybadger.contrib.flask.FlaskHoneybadger`. The extension adds the following information to reported exceptions:

- **url**: The URL the request was sent to.
- **component**: The module that the view is defined at. If the view is a class-based view, then the name of the class is also added.
- **action**: The name of the function called. If the action is defined within a blueprint, then the action name will have the name of the blueprint prefixed.
- **params**: A dictionary containing query parameters and form data. If a variable is defined in both, then the form data are stored. Params are filtered (see [Configuration](#configuration)).
- **session**: Session data.
- **cgi_data**: Request headers, filtered (see [Configuration](#configuration)) and request method.

In addition, the `FlaskHoneybadger` extension:
- Configures Honeybadger using Flask's [configuration object](http://flask.pocoo.org/docs/latest/config/#configuration-basics).
- (Optionally) Automatically report exceptions raised during views.
- (Optionally) Reset honeybadger context after each request.

> Note that `FlaskHoneybadger` uses Flask's [signals](http://flask.pocoo.org/docs/latest/signals/) in order to detect exceptions. In
order for the extension to work, you'll have to install the `blinker` library as dependency.

`FlaskHoneybadger` checks Flask's configuration object for automatically configuring honeybadger. In order to configure it, it checks for the
keys with same name as the environment variables in [Configuration](#configuration) section. Note that if a value is also configured as an environment variable,
then the environment variable's value will be used.

#### Example

```python
from flask import Flask, jsonify, request
from honeybadger.contrib import FlaskHoneybadger

app = Flask(__name__)
app.config['HONEYBADGER_ENVIRONMENT'] = 'production'
app.config['HONEYBADGER_API_KEY'] = '{{PROJECT_API_KEY}}'
app.config['HONEYBADGER_PARAMS_FILTERS'] = 'password, secret, credit-card'
FlaskHoneybadger(app, report_exceptions=True)

@app.route('/')
def index():
    a = int(request.args.get('a'))
    b = int(request.args.get('b'))

print('Dividing two numbers {} {}'.format(a, b))
    return jsonify({'result': a / b})

[...]

```

The code above will:

- Initialize honeybadger using Flask's configuration.
- Listen for exceptions.
- Log unhandled exceptions to Honeybadger.
- It will also add `url`, `component`, `action`, `params`, `cgi_data` and context (as generated by context generators) to all errors send using `honeybadger.notify()`.

> `FlaskHoneybadger` will catch exception raised from a view. Note that calls to `abort` method result in an exception being raised. If you don't want this
behavior, you can set `report_exceptions` to False and just call `honeybadger.notify` inside your exception handler.

You can also check more examples under directory `examples`.

#### Component naming in Flask

The following conventions are used for component names:

- When using view functions, the name of the component will be _\<module name>___#___\<view name>_
- For class-based views, the name of the component will be _\<module name>___#___\<class name>_
- When using blueprints, the name of the component will be  _\<module name>___#___\<blueprint name>_._\<view name>_

### AWS Lambda

AWS Lambda environments are auto detected by Honeybadger with no additional configuration.
Here's an example lambda function with Honeybadger:

```python
from honeybadger import honeybadger
honeybadger.configure(api_key='{{PROJECT_API_KEY}}')

def lambda_handler(event, context):
    """
    A buggy lambda function that tries to perform a zero division
    """
    a = 1
    b = 0

return (a/b) #This will be reported
```

### ASGI

A generic [ASGI](https://asgi.readthedocs.io/en/latest/) middleware plugin is available for initializing and configuring Honeybadger: [`honeybadger.contrib.asgi`](./honeybadger/contrib/asgi.py).

The general pattern for these cases is wrapping your ASGI application with a middleware:

```python
from honeybadger import contrib

asgi_application = someASGIApplication()
asgi_application = contrib.ASGIHoneybadger(asgi_application)
```

You can pass configuration parameters (or *additional* configuration parameters) as keyword arguments at plugin's initialization:

```python
from honeybadger import contrib

asgi_application = someASGIApplication()
asgi_application = contrib.ASGIHoneybadger(asgi_application, api_key="{{PROJECT_API_KEY}}", params_filters=["sensible_data"])

```

Or you may want to initialize Honeybadger before your application, and then just registering the plugin/middleware:

```python
from honeybadger import honeybadger, contrib

honeybadger.configure(api_key='{{PROJECT_API_KEY}}')
some_possibly_failing_function()  # you can track errors happening before your plugin initialization.
asgi_application = someASGIApplication()
asgi_application = contrib.ASGIHoneybadger(asgi_application)
```

### FastAPI

[FastAPI](https://fastapi.tiangolo.com/) is based on Starlette, an ASGI application.
You use Honeybadger's ASGI middleware on these types of applications.

```python

from fastapi import FastAPI
from honeybadger import contrib

app = FastAPI()
app.add_middleware(contrib.ASGIHoneybadger)
```

You can pass additional keyword paramters, too:

```python
from fastapi import FastAPI
from honeybadger import honeybadger, contrib

honeybadger.configure(api_key="{{PROJECT_API_KEY}}")
app = FastAPI()
app.add_middleware(contrib.ASGIHoneybadger, params_filters=["dont-include-this"])
```

#### FastAPI advanced usage.

Consuming the request body in an ASGI application's middleware is [problematic and discouraged](https://github.com/encode/starlette/issues/495#issuecomment-494008175). This is the reason why request body data won't be sent to the web UI.

FastAPI allows overriding the logic used by the `Request` and `APIRoute` classes, by [using custom `APIRoute` classes](https://fastapi.tiangolo.com/advanced/custom-request-and-route/). This gives more control over the request body, and makes it possible to send request body data along with honeybadger notifications.

A custom API Route is available at [`honeybadger.contrib.fastapi`](./honeybadger/contrib/fastapi).

Here's an example of setting the router class:

```python
from fastapi import FastAPI
from honeybadger import honeybadger
from honeybadger.contrib.fastapi import HoneybadgerRoute

honeybadger.configure(api_key="{{PROJECT_API_KEY}}")
app = FastAPI()
app.router.route_class = HoneybadgerRoute
```

Here's an example of creating a new `APIRouter` instance:

```python
from fastapi import FastAPI, APIRouter
from honeybadger import honeybadger
from honeybadger.contrib.fastapi import HoneybadgerRoute

honeybadger.configure(api_key="{{PROJECT_API_KEY}}")
app = FastAPI()
router = APIRouter(route_class=HoneybadgerRoute)
app.router = router
```

### Starlette
You can configure Honeybadger to work with [Starlette](https://www.starlette.io/) just like in any other ASGI framework.

```python
from starlette.applications import Starlette
from starlette.middleware import Middleware
from honeybadger import contrib

app = Starlette()
app.add_middleware(contrib.ASGIHoneybadger)
```

### Celery

A Celery extension is available for initializing and configuring Honeybadger: `honeybadger.contrib.celery.CeleryHoneybadger`. The extension adds the following information to reported exceptions:

- **component**: The module that the task is defined at.
- **action**: The name of the task.
- **params**: The arguments and keyword arguments passed to the task.
- **context**: A dictionary containing the following:
  - **task_id**: The id of the current task.
  - **retries**: The number of retries that have been attempted.
  - **max_retries**: The maximum number of retries that will be attempted.

#### Example

```python
from celery import Celery
from honeybadger.contrib import CeleryHoneybadger

app = Celery(__name__)
app.conf.update(
  HONEYBADGER_API_KEY= '<your key>',
  HONEYBADGER_ENVIRONMENT= 'production'
)
CeleryHoneybadger(app, report_exceptions=True)
```

### Oban

Honeybadger integrates with [Oban](https://github.com/oban-bg/oban-py) to report unhandled worker exceptions and emit per-job telemetry to Honeybadger Insights.

Requires Python 3.12+ and `oban>=0.6.2`.

```python
from oban import Oban
from honeybadger import honeybadger
from honeybadger.contrib.oban import ObanHoneybadger

honeybadger.configure(api_key="...", insights_enabled=True)
ObanHoneybadger(report_exceptions=True).init()

async with Oban(pool=pool, queues={"default": 10}) as oban:
    ...
```

`report_exceptions=True` installs an `executor.wrap_result` extension that calls `honeybadger.notify` whenever a worker raises. When `insights_enabled=True`, the integration also emits `oban.job_finished` events (and `oban.<loop>_exception` events for maintenance-loop failures).

Configuration:

```python
honeybadger.configure(insights_config={
    "oban": {
        "exclude_workers": ["myapp.NoisyWorker"],
        "include_args": True,  # include job.args / job.meta in Insights events (default: False)
    }
})
```

`exclude_workers` filters Insights events only — error reporting is unaffected.

Honeybadger event context set before enqueueing a job is automatically propagated through `job.meta` so the Insights timeline can link the enqueuing request to the worker's execution.

Only one `ObanHoneybadger` instance may be active per process. Call `tearDown()` to fully reverse all wiring (useful in tests or for application shutdown hooks).

### Other frameworks / plain Python app

Django and Flask are the only explicitly supported frameworks at the moment. For other frameworks (tornado, web2py, etc.) or a plain Python script, simply import honeybadger and configure it with your API key. Honeybadger uses a global exception hook to automatically report any uncaught exceptions.

```python
from honeybadger import honeybadger
honeybadger.configure(api_key='{{PROJECT_API_KEY}}')

raise Exception("This will get reported!")
```

### All set!

That's it! For additional configuration options, keep reading.

**Note:** By default, honeybadger reports errors in separate threads. For platforms that disallows threading (such as serving a flask/django app with uwsgi and disabling threading), Honeybadger will fail to report errors. You can either enable threading if you have the option, or set `force_sync` config option to `True`. This causes Honeybadger to report errors in a single thread.

## Insights Automatic Instrumentation

Honeybadger Insights allows you to automatically track various events in your
application. To enable Insights automatic instrumentation, add the following to
your configuration:

```python
honeybadger.configure(insights_enabled=True)
```

### Supported Libraries

After integration with our middleware or extensions, Honeybadger will
automatically instrument the following libraries:

- Django requests & database queries
- Flask requests & database queries
- ASGI requests
- Celery tasks
- Oban workers & maintenance loops

### Configuration

You can configure the instrumentation for specific libraries / components by
passing a dictionary to a specialized `insights_config` parameter.

By default, all keyword dict params are run through our `params_filters`.

The following instrumentation configs are available:

#### Django

```python
    honeybadger.configure(
        insights_config={
            "django": {
                # Disable instrumentation for Django, defaults to False
                "disabled": True,
                # include GET/POST params in events, defaults to False
                "include_params": True,
            }
        }
    )
```

#### Flask

```python
    honeybadger.configure(
        insights_config={
            "flask": {
                # Disable instrumentation for Flask, defaults to False
                "disabled": True,
                # Include GET/POST params in events, defaults to False
                "include_params": True,
            }
        }
    )
```

#### ASGI

```python
    honeybadger.configure(
        insights_config={
            "asgi": {
                # Disable instrumentation for ASGI, defaults to False
                "disabled": True,
                # Include query params in events, defaults to False
                "include_params": True,
            }
        }
    )
```

#### Celery

```python
    honeybadger.configure(
        insights_config={
            "celery": {
                # Disable instrumentation for Celery, defaults to False
                "disabled": True,
                # Include task args/kwargs, defaults to False
                "include_args": True,
                # List of task names or regexes to exclude, defaults to []
                "exclude_tasks": [
                    "tasks.cleanup",
                    re.compile("^internal_"),
                ],
            }
        }
    )
```

#### Oban

Configure per-integration options for Oban. All fields are optional.

```python
    honeybadger.configure(
        insights_config={
            "oban": {
                # Disable instrumentation for Oban, defaults to False
                "disabled": False,
                # Exact strings or compiled regex patterns to exclude, defaults to []
                "exclude_workers": ["myapp.NoisyWorker"],
                # Include job.args / job.meta in Insights events, defaults to False
                "include_args": False,
            }
        }
    )
```

`exclude_workers` patterns match against the worker's fully-qualified class name. String patterns are exact-match; compiled regex patterns use `.search()`. `exclude_workers` filters Insights events only — error reporting is unaffected.

#### DB

To configure database instrumentation, you can pass a dictionary to the
"db" insights config. This will affect all supported libraries that use capture
database events.

```python
    honeybadger.configure(
        insights_config={
            "db": {
                # Disable instrumentation for DB, defaults to False
                "disabled": True,
                # Include SQL params in events, defaults to False
                "include_params": True,

# List of task names or regexes to exclude, defaults to
                # `honeybadger.config.default_excluded_queries()`
                "exclude_queries": [
                    "django_admin_log",                 # Matches any query containing this string
                    re.compile(r".*auth_permission.*"), # Regex pattern
                ],

# To add to the default excluded queries, use the `honeybadger.config.default_excluded_queries()` method
                "exclude_queries": honeybadger.config.default_excluded_queries() + [
                    re.compile(r".*django_admin_log.*"),
                    re.compile(r".*auth_permission.*"),
                ],
            }
        }
    )
```

## Logging

By default, Honeybadger uses the `logging.NullHandler` for logging so it doesn't make any assumptions about your logging setup. In Django, add a `honeybadger` section to your `LOGGING` config to enable Honeybadger logging. For example:

```python
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': '/path/to/django/debug.log',
        },
    },
    'loggers': {
        'honeybadger': {
            'handlers': ['file'],
            'level': 'DEBUG',
            'propagate': True,
        },
    },
}
```

For other frameworks or a plain Python script, you can use `logging.dictConfig` or explicitly configure it like so:

```python
import logging
logging.getLogger('honeybadger').addHandler(logging.StreamHandler())
```

### Log Handler
Honeybadger includes a log handler that can be used to report logs of any level via python's logging module.

```python
import logging
from honeybadger.contrib.logger import HoneybadgerHandler

hb_handler = HoneybadgerHandler(api_key='{{PROJECT_API_KEY}}')
logger = logging.getLogger('honeybadger')
logger.addHandler(hb_handler)

try:
  1/0
except:
  logger.error("Something went wrong")
```

or using Dict Config:

```python
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'honeybadger': {
            'level': 'ERROR',
            'class': 'honeybadger.contrib.logger.HoneybadgerHandler',
            'api_key': '{{PROJECT_API_KEY}}',
        },
    },
    'loggers': {
        # root logger
        '': {
            'level': 'WARNING',
            'handlers': ['console', 'honeybadger'],
        },
    },
}
```

## Configuration

To set configuration options, use the `honeybadger.configure` method, like so:

```python
honeybadger.configure(api_key='{{PROJECT_API_KEY}}', environment='production')
```

Most of Honeybadger's configuration options can also be set via environment variables with the `HONEYBADGER` prefix (12-factor style). For example, the `api_key` option can be set via the `HONEYBADGER_API_KEY` environment variable.

The following options are available to you:

| Name                     | Type       | Default                                                | Example                               | Environment variable                  |
|--------------------------|------------|--------------------------------------------------------|---------------------------------------|---------------------------------------|
| api_key                  | `str`      | `""`                                                   | `"badgers"`                           | `HONEYBADGER_API_KEY`                 |
| project_root             | `str`      | The current working directory                          | `"/path/to/project"`                  | `HONEYBADGER_PROJECT_ROOT`            |
| environment[^1]          | `str`      | `"production"`                                         | `"staging"`                           | `HONEYBADGER_ENVIRONMENT`             |
| development_environments | `list`     | `['development', 'dev', 'test']`                       | `['staging', 'local']`                | `HONEYBADGER_DEVELOPMENT_ENVIRONMENTS`|
| hostname                 | `str`      | The hostname of the current server.                    | `"badger01"`                          | `HONEYBADGER_HOSTNAME`                |
| endpoint                 | `str`      | `"https://api.honeybadger.io"`                         | `"https://honeybadger.example.com/"`  | `HONEYBADGER_ENDPOINT`                |
| params_filters           | `list`     | `['password', 'password_confirmation', 'credit_card']` | `['super', 'secret', 'keys']`         | `HONEYBADGER_PARAMS_FILTERS`          |
| force_report_data        | `bool`     | `False`                                                | `True`                                | `HONEYBADGER_FORCE_REPORT_DATA`       |
| before_notify            | `callable` | `lambda notice: notice`                                | `custom_before_notify_function`       | n/a                                   |
| excluded_exceptions      | `list`     | `[]`                                                   | `['Http404', 'MyCustomIgnoredError']` | `HONEYBADGER_EXCLUDED_EXCEPTIONS`     |
| force_sync               | `bool`     | `False`                                                | `True`                                | `HONEYBADGER_FORCE_SYNC`              |
| report_local_variables   | `bool`     | `False`                                                | `True`                                | `HONEYBADGER_REPORT_LOCAL_VARIABLES`  |
| insights_enabled         | `bool`     | `False`                                                | `True`                                | `HONEYBADGER_INSIGHTS_ENABLED`        |
| before_event             | `callable` | `lambda notice: None`                                  | `custom_before_notify_function`       | n/a                                   |
| events_batch_size        | `int`      | `1000`                                                 | `50`                                  | `HONEYBADGER_EVENTS_BATCH_SIZE`       |
| events_max_queue_size    | `int`      | `10000`                                                | `5000`                                | `HONEYBADGER_EVENTS_MAX_QUEUE_SIZE`   |
| events_timeout           | `float`    | `5.0`                                                  | `1.0`                                 | `HONEYBADGER_EVENTS_TIMEOUT`          |
| events_max_batch_retries | `int`      | `3`                                                    | `5`                                   | `HONEYBADGER_EVENTS_MAX_BATCH_RETRIES`|
| events_throttle_wait     | `float`    | `60.0`                                                 | `1200.0`                              | `HONEYBADGER_EVENTS_THROTTLE_WAIT`    |

[^1]: Honeybadger will try to infer the correct environment when possible. For example, in the case of the Django integration, if Django settings are set to `DEBUG = True`, the environment will default to `development`.

## Public Methods

### `honeybadger.set_context`: Set global context data

This method allows you to send additional information to the Honeybadger API to assist in debugging. This method sets global context data and is additive  - eg. every time you call it, it adds to the existing set unless you call `reset_context`, documented below.

#### Examples:

```python
from honeybadger import honeybadger
honeybadger.set_context(my_data='my_value')
```

### `honeybadger.reset_context`: Clear global context data

This method clears the global context dictionary.

#### Examples:

```python
from honeybadger import honeybadger
honeybadger.reset_context()
```

### `honeybadger.context`: Python context manager interface

What if you don't want to set global context data? You can use Python context managers to set case-specific contextual information.

#### Examples:

```python
# from a Django view
from honeybadger import honeybadger
def my_view(request):
  with honeybadger.context(user_email=request.POST.get('user_email', None)):
    form = UserForm(request.POST)
    ...
```

### `honeybadger.configure`: Specify additional configuration options

Allows you to configure honeybadger within your code. Accepts any of the above-listed configuration options as keyword arguments.

#### Example:

```python
honeybadger.configure(api_key='{{PROJECT_API_KEY}}', project_root='/home/dave/crywolf-django')
```

### `honeybadger.notify`: Send an error notice to Honeybadger

In cases where you'd like to manually send error notices to Honeybadger, this is what you're looking for. You can either pass it an exception as the first argument, or an `error_class`/`error_message` pair of keyword arguments.
You can also pass it a:
- custom context dictionary which will get merged with the global context
- `fingerprint` option to customize the [error grouping](https://docs.honeybadger.io/guides/errors/#error-grouping)

#### Examples:

```python
# with an exception
mydict = dict(a=1)
try:
  print mydict['b']
except KeyError as exc:
  honeybadger.notify(exc, context={'foo': 'bar'})

# with custom arguments
honeybadger.notify(error_class='ValueError', error_message='Something bad happened!', fingerprint='custom_fingerprint')
```

### `honeybadger.event`: Send custom events to Honeybadger Insights

Use this method to send custom events to [Honeybadger Insights](https://docs.honeybadger.io/guides/insights/). This allows you to track and monitor important events in your application.

#### Examples:

```python
# Send a simple event
honeybadger.event('user.signup', dict(email='user@example.com'))
# or using keyword arguments
honeybadger.event(event_type='user.signup', data=dict(email='user@example.com'))

# Send an event with additional metadata
honeybadger.event(
    event_type='order.completed',
    data=dict(
        order_id='123',
        total=49.99,
        items=['item1', 'item2']
    )
)
# or
honeybadger.event(
    dict(
        event_type='order.completed',
        order_id='123',
        total=49.99,
        items=['item1', 'item2']
    )
)
```

The `event` method takes two parameters:
- `event_type`: A string identifying the event type
- `data`: A dictionary containing any additional data about the event

`event_type` is not required, but it's recommended as a way to group your events. A `ts` key is also added to `data` if not present with the value `time.time()`.

## Development

### Python environment setup

A simple way to setup a python environment is to use [asdf](https://asdf-vm.com/#/). After installing `asdf`, run the following commands:
1. `asdf install python 3.9.16`
2. `asdf local python 3.9.16`

### Installing dependencies

After cloning the repo, run:

```sh
pip install -r dev-requirements.txt
```

### Unit tests

To run the unit tests:

```sh
python -m pytest
```

### Linting

To ensure code consistency, run `black` to autoformat your code:

```sh
black ./honeybadger
```

Then run `pylint` to check for any linting errors:

```sh
pylint -E ./honeybadger
```

## Contributing

If you're adding a new feature, please [submit an issue](https://github.com/honeybadger-io/honeybadger-python/issues/new) as a preliminary step; that way you can be (moderately) sure that your pull request will be accepted.

### To contribute your code:

1. Fork it.
1. Create a topic branch `git checkout -b my_branch`
1. Ensure the tests pass `python -m pytest`
1. Run black for consistency `black ./honeybadger`
1. Run pylint for linting `pylint -E ./honeybadger`
1. Commit your changes `git commit -am "Boom"`
1. Push to your branch `git push origin my_branch`
1. Send a [pull request](https://github.com/honeybadger-io/honeybadger-python/pulls)

## Changelog

See https://github.com/honeybadger-io/honeybadger-python/blob/master/CHANGELOG.md

## Publishing a release on PyPI

### Github Workflow

A new version can be published on PyPi using the [Publish new version on PyPi](.github/workflows/pypi-publish.yml) workflow.
Before triggering the workflow, ensure that upcoming version changes in [CHANGELOG.md](./CHANGELOG.md) are recorded in the `Unreleased` section.
The workflow can be triggered manually from the Github Actions page and takes a version input.

### Manual Release

1. Ensure the latest version of twine is installed with `pip install --upgrade twine wheel`
1. Update the version in [honeybadger/version.py](./honeybadger/version.py)
1. Update unreleased heading in [CHANGELOG.md](./CHANGELOG.md)
1. Commit changes with "Release [version]", i.e.: "Release 0.3.0" ([example
   commit](https://github.com/honeybadger-io/honeybadger-python/commit/8e22bdcbc23c74494082cf2521418483a87d59e5))
1. Tag changes: `git tag v[version]`, i.e.: `git tag v0.3.0`
1. Push changes to GitHub: `git push origin master --tags`
1. Clean out the existing dist dir with `rm -rf dist/`
1. Run `python3 setup.py bdist_wheel` which will build the python3 package in dist/
1. Run `twine upload dist/*` to upload the release to PyPI

## License

This project is MIT licensed. See the [LICENSE](https://github.com/honeybadger-io/honeybadger-python/blob/master/LICENSE) file in this repository for details.

honeybadger-python

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README