alarmer

Alarmer is a tool focus on error reporting for your application, like sentry but lightweight.

Installation

pip install alarmer

Usage

It's simple to integrate alarmer in your application, just call Alarmer.init on startup of your application.

import os

from alarmer import Alarmer
from alarmer.provider.feishu import FeiShuProvider


def main():
    Alarmer.init(providers=[FeiShuProvider(webhook_url=os.getenv("FEI_SHU_WEBHOOK_URL"))])
    raise Exception("test")


if __name__ == "__main__":
    main()

Intercept Error Logging

If you want to intercept the logging, you can use LoggingHandler.

import logging
import os

from alarmer import Alarmer
from alarmer.log import LoggingHandler
from alarmer.provider.feishu import FeiShuProvider


def main():
    Alarmer.init(providers=[FeiShuProvider(webhook_url=os.getenv("FEI_SHU_WEBHOOK_URL"))])
    logging.basicConfig(
        level=logging.INFO,
    )
    logger = logging.getLogger()
    logger.addHandler(LoggingHandler(level=logging.ERROR))  # only error and above should be send
    logging.error("test logging")


if __name__ == "__main__":
    main()

Now when you run the script, you will receive the errors in your provider.

Provider

You can set number of providers for error reporting. All kinds of providers can be found in providers.

Thanks to Apprise, you can use lots of providers out of box.

• Apprise
• FeiShu
• WeCom

Custom Provider

You can write your own custom provider by inheriting the Provider class.

from typing import Optional
from alarmer.provider import Provider


class CustomProvider(Provider):

    def send(self, message: str, exc: Optional[BaseException] = None, context: Optional[dict] = None):
        # Send to your custom provider here
        pass

In addition to this, you can just write a callable function which takes message and exc arguments.

from typing import Optional


def custom_provider(message: str, exc: Optional[BaseException] = None, context: Optional[dict] = None):
    # Send to your custom provider here
    pass

Then add it to Alarmer.init.

from alarmer import Alarmer

Alarmer.init(providers=[CustomProvider(), custom_provider])

Throttling

Throttling is used to throttling error messages if there are too many errors.

from alarmer import Alarmer
from alarmer.throttling import Throttling

Alarmer.init(global_throttling=Throttling(), providers=[...])

Custom Throttling

You can write your own throttling by inheriting the Throttling class.

import typing

from alarmer.throttling import Throttling

if typing.TYPE_CHECKING:
    from alarmer.provider import Provider


class MyThrottling(Throttling):
    def __call__(self, provider: "typing.Union[Provider,typing.Callable]", message: str,
                 exc: typing.Optional[BaseException] = None, context: typing.Optional[dict] = None) -> bool:
        # check whether the error message should be send
        return True

Manual Send

If you want to manually send messages to the providers, just call Alarmer.send.

from alarmer import Alarmer

Alarmer.send("message")

License

This project is licensed under the Apache-2.0 License.