automatic import of python-structlog-sentry

3 files changed, 655 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..d7f93f3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/structlog-sentry-2.0.0.tar.gz
diff --git a/python-structlog-sentry.spec b/python-structlog-sentry.spec
new file mode 100644
index 0000000..6524622
--- /dev/null
+++ b/python-structlog-sentry.spec
@@ -0,0 +1,653 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-structlog-sentry
+Version:	2.0.0
+Release:	1
+Summary:	Sentry integration for structlog
+License:	MIT
+URL:		https://github.com/kiwicom/structlog-sentry
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/55/2a/b4cc640f5abfd633406b0239fa271a5d116a3b4667477e0a5dabf95935ac/structlog-sentry-2.0.0.tar.gz
+BuildArch:	noarch
+
+Requires:	python3-sentry-sdk
+Requires:	python3-structlog
+
+%description
+# structlog-sentry
+
+| What          | Where                                         |
+| ------------- | --------------------------------------------- |
+| Documentation | <https://github.com/kiwicom/structlog-sentry> |
+| Maintainer    | @kiwicom/platform                             |
+
+Based on <https://gist.github.com/hynek/a1f3f92d57071ebc5b91>
+
+## Installation
+
+Install the package with [pip](https://pip.pypa.io/):
+
+```
+pip install structlog-sentry
+```
+
+## Usage
+
+This module is intended to be used with `structlog` like this:
+
+```python
+import sentry_sdk
+import structlog
+from structlog_sentry import SentryProcessor
+
+
+sentry_sdk.init()  # pass dsn in argument or via SENTRY_DSN env variable
+
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,  # optional, but before SentryProcessor()
+        structlog.stdlib.add_log_level,  # required before SentryProcessor()
+        SentryProcessor(event_level=logging.ERROR),
+    ],
+    logger_factory=...,
+    wrapper_class=...,
+)
+
+
+log = structlog.get_logger()
+```
+
+Do not forget to add the `structlog.stdlib.add_log_level` and optionally the
+`structlog.stdlib.add_logger_name` processors before `SentryProcessor`. The
+`SentryProcessor` class takes the following arguments:
+
+- `level` Events of this or higher levels will be reported as Sentry
+  breadcrumbs. Dfault is `logging.INFO`.
+- `event_level` Events of this or higher levels will be reported to Sentry
+  as events. Default is `logging.WARNING`.
+- `active` A flag to make this processor enabled/disabled.
+- `as_context` Send `event_dict` as extra info to Sentry. Default is `True`.
+- `tag_keys` A list of keys. If any if these keys appear in `event_dict`,
+  the key and its corresponding value in `event_dict` will be used as Sentry
+  event tags. use `"__all__"` to report all key/value pairs of event as tags.
+- `ignore_loggers` A list of logger names to ignore any events from.
+- `verbose` Report the action taken by the logger in the `event_dict`.
+  Default is `False`.
+- `hub` Optionally specify `sentry_sdk.Hub`.
+
+Now events are automatically captured by Sentry with `log.error()`:
+
+```python
+try:
+    1/0
+except ZeroDivisionError:
+    log.error("zero divsiion")
+
+try:
+    resp = requests.get(f"https://api.example.com/users/{user_id}/")
+    resp.raise_for_status()
+except RequestException:
+    log.error("request error", user_id=user_id)
+```
+
+This won't automatically collect `sys.exc_info()` along with the message, if you want
+to enable this behavior, just pass `exc_info=True`.
+
+When you want to use structlog's built-in
+[`format_exc_info`](http://www.structlog.org/en/stable/api.html#structlog.processors.format_exc_info)
+processor, make that the `SentryProcessor` comes *before* `format_exc_info`!
+Otherwise, the `SentryProcessor` won't have an `exc_info` to work with, because
+it's removed from the event by `format_exc_info`.
+
+Logging calls with no `sys.exc_info()` are also automatically captured by Sentry
+either as breadcrumbs (if configured by the `level` argument) or as events:
+
+```python
+log.info("info message", scope="accounts")
+log.warning("warning message", scope="invoices")
+log.error("error message", scope="products")
+```
+
+If you do not want to forward a specific logs into Sentry, you can pass the
+`sentry_skip=True` optional argument to logger methods, like this:
+
+```python
+log.error("error message", sentry_skip=True)
+```
+
+### Sentry Tags
+
+You can set some or all of key/value pairs of structlog `event_dict` as sentry `tags`:
+
+```python
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        SentryProcessor(level=logging.ERROR, tag_keys=["city", "timezone"]),
+    ],...
+)
+
+log.error("error message", city="Tehran", timezone="UTC+3:30", movie_title="Some title")
+```
+
+this will report the error and the sentry event will have **city** and **timezone** tags.
+If you want to have all event data as tags, create the `SentryProcessor` with `tag_keys="__all__"`.
+
+```python
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        SentryProcessor(level=logging.ERROR, tag_keys="__all__"),
+    ],...
+)
+```
+
+### Skip Context
+
+By default `SentryProcessor` will send `event_dict` key/value pairs as contextual info to sentry.
+Sometimes you may want to skip this, specially when sending the `event_dict` as sentry tags:
+
+```python
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        SentryProcessor(level=logging.ERROR, as_context=False, tag_keys="__all__"),
+    ],...
+)
+```
+
+### Ignore specific loggers
+
+If you want to ignore specific loggers from being processed by the `SentryProcessor` just pass
+a list of loggers when instantiating the processor:
+
+```python
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        SentryProcessor(level=logging.ERROR, ignore_loggers=["some.logger"]),
+    ],...
+)
+```
+
+### Logging as JSON
+
+If you want to configure `structlog` to format the output as **JSON** (maybe for
+[elk-stack](https://www.elastic.co/elk-stack)) you have to disable standard logging
+integration in Sentry SDK by passing the `LoggingIntegration(event_level=None, level=None)`
+instance to `sentry_sdk.init` method. This prevents duplication of an event reported to sentry:
+
+```python
+from sentry_sdk.integrations.logging import LoggingIntegration
+
+
+INTEGRATIONS = [
+    # ... other integrations
+    LoggingIntegration(event_level=None, level=None),
+]
+
+sentry_sdk.init(integrations=INTEGRATIONS)
+```
+
+This integration tells `sentry_sdk` to *ignore* standard logging and captures the events manually.
+
+## Testing
+
+To run all tests:
+
+```
+tox
+```
+
+## Contributing
+
+Create a merge request and tag @kiwicom/platform  for review.
+
+
+
+%package -n python3-structlog-sentry
+Summary:	Sentry integration for structlog
+Provides:	python-structlog-sentry
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-structlog-sentry
+# structlog-sentry
+
+| What          | Where                                         |
+| ------------- | --------------------------------------------- |
+| Documentation | <https://github.com/kiwicom/structlog-sentry> |
+| Maintainer    | @kiwicom/platform                             |
+
+Based on <https://gist.github.com/hynek/a1f3f92d57071ebc5b91>
+
+## Installation
+
+Install the package with [pip](https://pip.pypa.io/):
+
+```
+pip install structlog-sentry
+```
+
+## Usage
+
+This module is intended to be used with `structlog` like this:
+
+```python
+import sentry_sdk
+import structlog
+from structlog_sentry import SentryProcessor
+
+
+sentry_sdk.init()  # pass dsn in argument or via SENTRY_DSN env variable
+
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,  # optional, but before SentryProcessor()
+        structlog.stdlib.add_log_level,  # required before SentryProcessor()
+        SentryProcessor(event_level=logging.ERROR),
+    ],
+    logger_factory=...,
+    wrapper_class=...,
+)
+
+
+log = structlog.get_logger()
+```
+
+Do not forget to add the `structlog.stdlib.add_log_level` and optionally the
+`structlog.stdlib.add_logger_name` processors before `SentryProcessor`. The
+`SentryProcessor` class takes the following arguments:
+
+- `level` Events of this or higher levels will be reported as Sentry
+  breadcrumbs. Dfault is `logging.INFO`.
+- `event_level` Events of this or higher levels will be reported to Sentry
+  as events. Default is `logging.WARNING`.
+- `active` A flag to make this processor enabled/disabled.
+- `as_context` Send `event_dict` as extra info to Sentry. Default is `True`.
+- `tag_keys` A list of keys. If any if these keys appear in `event_dict`,
+  the key and its corresponding value in `event_dict` will be used as Sentry
+  event tags. use `"__all__"` to report all key/value pairs of event as tags.
+- `ignore_loggers` A list of logger names to ignore any events from.
+- `verbose` Report the action taken by the logger in the `event_dict`.
+  Default is `False`.
+- `hub` Optionally specify `sentry_sdk.Hub`.
+
+Now events are automatically captured by Sentry with `log.error()`:
+
+```python
+try:
+    1/0
+except ZeroDivisionError:
+    log.error("zero divsiion")
+
+try:
+    resp = requests.get(f"https://api.example.com/users/{user_id}/")
+    resp.raise_for_status()
+except RequestException:
+    log.error("request error", user_id=user_id)
+```
+
+This won't automatically collect `sys.exc_info()` along with the message, if you want
+to enable this behavior, just pass `exc_info=True`.
+
+When you want to use structlog's built-in
+[`format_exc_info`](http://www.structlog.org/en/stable/api.html#structlog.processors.format_exc_info)
+processor, make that the `SentryProcessor` comes *before* `format_exc_info`!
+Otherwise, the `SentryProcessor` won't have an `exc_info` to work with, because
+it's removed from the event by `format_exc_info`.
+
+Logging calls with no `sys.exc_info()` are also automatically captured by Sentry
+either as breadcrumbs (if configured by the `level` argument) or as events:
+
+```python
+log.info("info message", scope="accounts")
+log.warning("warning message", scope="invoices")
+log.error("error message", scope="products")
+```
+
+If you do not want to forward a specific logs into Sentry, you can pass the
+`sentry_skip=True` optional argument to logger methods, like this:
+
+```python
+log.error("error message", sentry_skip=True)
+```
+
+### Sentry Tags
+
+You can set some or all of key/value pairs of structlog `event_dict` as sentry `tags`:
+
+```python
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        SentryProcessor(level=logging.ERROR, tag_keys=["city", "timezone"]),
+    ],...
+)
+
+log.error("error message", city="Tehran", timezone="UTC+3:30", movie_title="Some title")
+```
+
+this will report the error and the sentry event will have **city** and **timezone** tags.
+If you want to have all event data as tags, create the `SentryProcessor` with `tag_keys="__all__"`.
+
+```python
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        SentryProcessor(level=logging.ERROR, tag_keys="__all__"),
+    ],...
+)
+```
+
+### Skip Context
+
+By default `SentryProcessor` will send `event_dict` key/value pairs as contextual info to sentry.
+Sometimes you may want to skip this, specially when sending the `event_dict` as sentry tags:
+
+```python
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        SentryProcessor(level=logging.ERROR, as_context=False, tag_keys="__all__"),
+    ],...
+)
+```
+
+### Ignore specific loggers
+
+If you want to ignore specific loggers from being processed by the `SentryProcessor` just pass
+a list of loggers when instantiating the processor:
+
+```python
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        SentryProcessor(level=logging.ERROR, ignore_loggers=["some.logger"]),
+    ],...
+)
+```
+
+### Logging as JSON
+
+If you want to configure `structlog` to format the output as **JSON** (maybe for
+[elk-stack](https://www.elastic.co/elk-stack)) you have to disable standard logging
+integration in Sentry SDK by passing the `LoggingIntegration(event_level=None, level=None)`
+instance to `sentry_sdk.init` method. This prevents duplication of an event reported to sentry:
+
+```python
+from sentry_sdk.integrations.logging import LoggingIntegration
+
+
+INTEGRATIONS = [
+    # ... other integrations
+    LoggingIntegration(event_level=None, level=None),
+]
+
+sentry_sdk.init(integrations=INTEGRATIONS)
+```
+
+This integration tells `sentry_sdk` to *ignore* standard logging and captures the events manually.
+
+## Testing
+
+To run all tests:
+
+```
+tox
+```
+
+## Contributing
+
+Create a merge request and tag @kiwicom/platform  for review.
+
+
+
+%package help
+Summary:	Development documents and examples for structlog-sentry
+Provides:	python3-structlog-sentry-doc
+%description help
+# structlog-sentry
+
+| What          | Where                                         |
+| ------------- | --------------------------------------------- |
+| Documentation | <https://github.com/kiwicom/structlog-sentry> |
+| Maintainer    | @kiwicom/platform                             |
+
+Based on <https://gist.github.com/hynek/a1f3f92d57071ebc5b91>
+
+## Installation
+
+Install the package with [pip](https://pip.pypa.io/):
+
+```
+pip install structlog-sentry
+```
+
+## Usage
+
+This module is intended to be used with `structlog` like this:
+
+```python
+import sentry_sdk
+import structlog
+from structlog_sentry import SentryProcessor
+
+
+sentry_sdk.init()  # pass dsn in argument or via SENTRY_DSN env variable
+
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,  # optional, but before SentryProcessor()
+        structlog.stdlib.add_log_level,  # required before SentryProcessor()
+        SentryProcessor(event_level=logging.ERROR),
+    ],
+    logger_factory=...,
+    wrapper_class=...,
+)
+
+
+log = structlog.get_logger()
+```
+
+Do not forget to add the `structlog.stdlib.add_log_level` and optionally the
+`structlog.stdlib.add_logger_name` processors before `SentryProcessor`. The
+`SentryProcessor` class takes the following arguments:
+
+- `level` Events of this or higher levels will be reported as Sentry
+  breadcrumbs. Dfault is `logging.INFO`.
+- `event_level` Events of this or higher levels will be reported to Sentry
+  as events. Default is `logging.WARNING`.
+- `active` A flag to make this processor enabled/disabled.
+- `as_context` Send `event_dict` as extra info to Sentry. Default is `True`.
+- `tag_keys` A list of keys. If any if these keys appear in `event_dict`,
+  the key and its corresponding value in `event_dict` will be used as Sentry
+  event tags. use `"__all__"` to report all key/value pairs of event as tags.
+- `ignore_loggers` A list of logger names to ignore any events from.
+- `verbose` Report the action taken by the logger in the `event_dict`.
+  Default is `False`.
+- `hub` Optionally specify `sentry_sdk.Hub`.
+
+Now events are automatically captured by Sentry with `log.error()`:
+
+```python
+try:
+    1/0
+except ZeroDivisionError:
+    log.error("zero divsiion")
+
+try:
+    resp = requests.get(f"https://api.example.com/users/{user_id}/")
+    resp.raise_for_status()
+except RequestException:
+    log.error("request error", user_id=user_id)
+```
+
+This won't automatically collect `sys.exc_info()` along with the message, if you want
+to enable this behavior, just pass `exc_info=True`.
+
+When you want to use structlog's built-in
+[`format_exc_info`](http://www.structlog.org/en/stable/api.html#structlog.processors.format_exc_info)
+processor, make that the `SentryProcessor` comes *before* `format_exc_info`!
+Otherwise, the `SentryProcessor` won't have an `exc_info` to work with, because
+it's removed from the event by `format_exc_info`.
+
+Logging calls with no `sys.exc_info()` are also automatically captured by Sentry
+either as breadcrumbs (if configured by the `level` argument) or as events:
+
+```python
+log.info("info message", scope="accounts")
+log.warning("warning message", scope="invoices")
+log.error("error message", scope="products")
+```
+
+If you do not want to forward a specific logs into Sentry, you can pass the
+`sentry_skip=True` optional argument to logger methods, like this:
+
+```python
+log.error("error message", sentry_skip=True)
+```
+
+### Sentry Tags
+
+You can set some or all of key/value pairs of structlog `event_dict` as sentry `tags`:
+
+```python
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        SentryProcessor(level=logging.ERROR, tag_keys=["city", "timezone"]),
+    ],...
+)
+
+log.error("error message", city="Tehran", timezone="UTC+3:30", movie_title="Some title")
+```
+
+this will report the error and the sentry event will have **city** and **timezone** tags.
+If you want to have all event data as tags, create the `SentryProcessor` with `tag_keys="__all__"`.
+
+```python
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        SentryProcessor(level=logging.ERROR, tag_keys="__all__"),
+    ],...
+)
+```
+
+### Skip Context
+
+By default `SentryProcessor` will send `event_dict` key/value pairs as contextual info to sentry.
+Sometimes you may want to skip this, specially when sending the `event_dict` as sentry tags:
+
+```python
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        SentryProcessor(level=logging.ERROR, as_context=False, tag_keys="__all__"),
+    ],...
+)
+```
+
+### Ignore specific loggers
+
+If you want to ignore specific loggers from being processed by the `SentryProcessor` just pass
+a list of loggers when instantiating the processor:
+
+```python
+structlog.configure(
+    processors=[
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        SentryProcessor(level=logging.ERROR, ignore_loggers=["some.logger"]),
+    ],...
+)
+```
+
+### Logging as JSON
+
+If you want to configure `structlog` to format the output as **JSON** (maybe for
+[elk-stack](https://www.elastic.co/elk-stack)) you have to disable standard logging
+integration in Sentry SDK by passing the `LoggingIntegration(event_level=None, level=None)`
+instance to `sentry_sdk.init` method. This prevents duplication of an event reported to sentry:
+
+```python
+from sentry_sdk.integrations.logging import LoggingIntegration
+
+
+INTEGRATIONS = [
+    # ... other integrations
+    LoggingIntegration(event_level=None, level=None),
+]
+
+sentry_sdk.init(integrations=INTEGRATIONS)
+```
+
+This integration tells `sentry_sdk` to *ignore* standard logging and captures the events manually.
+
+## Testing
+
+To run all tests:
+
+```
+tox
+```
+
+## Contributing
+
+Create a merge request and tag @kiwicom/platform  for review.
+
+
+
+%prep
+%autosetup -n structlog-sentry-2.0.0
+
+%build
+%py3_build
+
+%install
+%py3_install
+install -d -m755 %{buildroot}/%{_pkgdocdir}
+if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
+if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
+if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
+if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
+pushd %{buildroot}
+if [ -d usr/lib ]; then
+	find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/lib64 ]; then
+	find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/bin ]; then
+	find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/sbin ]; then
+	find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+touch doclist.lst
+if [ -d usr/share/man ]; then
+	find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
+fi
+popd
+mv %{buildroot}/filelist.lst .
+mv %{buildroot}/doclist.lst .
+
+%files -n python3-structlog-sentry -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Mon Apr 10 2023 Python_Bot <Python_Bot@openeuler.org> - 2.0.0-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..a007034
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+7459bbb74e1f2063c05d538f82eee96e  structlog-sentry-2.0.0.tar.gz