automatic import of python-opentracing-async-instrumentation

3 files changed, 491 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..d7ada38 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/opentracing_async_instrumentation-0.2.1.tar.gz
diff --git a/python-opentracing-async-instrumentation.spec b/python-opentracing-async-instrumentation.spec
new file mode 100644
index 0000000..80b7768
--- /dev/null
+++ b/python-opentracing-async-instrumentation.spec
@@ -0,0 +1,489 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-opentracing-async-instrumentation
+Version:	0.2.1
+Release:	1
+Summary:	Async Tracing Instrumentation using OpenTracing API (http://opentracing.io)
+License:	MIT
+URL:		https://gitlab.com/midigator/python_opentracing_async_instrumentation/
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/ab/29/2ab7c96b4796361fb33aa311ce3bc8bc23579e943310872e9dd4da94d68f/opentracing_async_instrumentation-0.2.1.tar.gz
+BuildArch:	noarch
+
+Requires:	python3-future
+Requires:	python3-wrapt
+Requires:	python3-contextlib2
+Requires:	python3-opentracing
+Requires:	python3-six
+Requires:	python3-aiohttp
+Requires:	python3-aiobotocore
+Requires:	python3-aioboto3
+Requires:	python3-aiomysql
+Requires:	python3-basictracer
+Requires:	python3-flake8
+Requires:	python3-mock
+Requires:	python3-moto[server]
+Requires:	python3-pytest
+Requires:	python3-pytest-cov
+Requires:	python3-pytest-localserver
+Requires:	python3-pytest-mock
+Requires:	python3-pytest-asyncio
+Requires:	python3-pytest-aiohttp
+Requires:	python3-testfixtures
+Requires:	python3-tox
+
+%description
+[![PyPI version][pypi-img]][pypi] [![Python versions][pyver-img]][pypi] [![Pypi Downloads][pydl-img]][pypi] [![Build Status][ci-img]][ci] [![Coverage Status][cov-img]][cov]
+
+
+# python-opentracing-async-instrumentation
+
+A collection of asyncio instrumentation tools to enable tracing with [OpenTracing API](http://opentracing.io).
+
+## Module
+
+Make sure you are running recent enough versions of `pip` and `setuptools`, e.g. before installing your project requirements execute this:
+
+```
+pip install --upgrade "setuptools>=29" "pip>=9"
+```
+
+The module name is `opentracing_async_instrumentation`.
+
+## What's inside
+
+### Supported client frameworks
+
+The following libraries are instrumented for tracing in this module:
+ * [aiobotocore](https://github.com/aio-libs/aiobotocore) — Asyncio AWS SDK for Python
+ * [aioboto3](https://github.com/terrycain/aioboto3) — Asyncio AWS SDK for Python (uses aiobotocore under the hood)
+ * [aiohttp](https://github.com/aio-libs/aiohttp/) - Asyncio HTTP server and client
+ * [aiomysql](https://github.com/aio-libs/aiomysql)
+
+#### Limitations
+
+ * Only Python 3.5+ is currently supported.
+
+### Server instrumentation
+
+For inbound requests a helper function `before_request` is provided for creating middleware for frameworks like aiohttp and possibly Tornado.
+
+A middleware is provided for `aiohttp`.
+
+### In-process Context Propagation
+
+As part of the OpenTracing 2.0 API, in-process `Span` propagation happens through the newly defined
+[ScopeManager](https://opentracing-python.readthedocs.io/en/latest/api.html#scope-managers)
+interface.
+
+## Usage
+
+This library provides two types of instrumentation, explicit instrumentation
+for server endpoints, and implicit instrumentation for client call sites.
+
+### Server
+
+Server endpoints are instrumented by creating a (or using a provided) middleware class that:
+
+ 1. initializes the specific tracer implementation
+ 2. wraps incoming request handlers into a method that reads the incoming
+    tracing info from the request and creates a new tracing Span
+
+```python
+from aiohttp import web
+from opentracing_async_instrumentation.client_hooks import aiohttpserver
+
+async def handler(request):
+    return web.Response(body='Hello World')
+
+app = web.Application()
+app.router.add_get('/', handler)
+app.middlewares.append(aiohttpserver.enable_tracing)
+
+if __name__ == '__main__':
+    web.run_app(app)
+```
+
+### Client
+
+Client call sites are instrumented implicitly by executing a set of
+available `client_hooks` that monkey-patch some API points in several
+common libraries like `aiohttp` and `aiobotocore`. The initialization of
+those hooks is usually also done from the middleware class's `__init__` method.
+
+Usage is via the `client_hooks` interface.
+
+```python
+from opentracing_async_instrumentation import client_hooks
+
+client_hooks.install_all_patches()
+```
+
+### Customization
+
+For the `aiohttp` library, in case you want to set custom tags
+to spans depending on content or some metadata of responses,
+you can set `response_handler_hook`.
+The hook must be a method with a signature `(response, span)`,
+where `response` and `span` are positional arguments,
+so you can use different names for them if needed.
+
+```python
+from opentracing_async_instrumentation.client_hooks.aiohttpclient import patcher
+
+
+def hook(response, span):
+    if not response.ok:
+        span.set_tag('error', 'true')
+
+
+patcher.set_response_handler_hook(hook)
+```
+
+## Development
+
+To prepare a development environment please execute the following commands.
+```bash
+virtualenv env
+source env/bin/activate
+make bootstrap
+make test
+```
+
+You can use [tox](https://tox.readthedocs.io) to run tests as well.
+```bash
+tox
+```
+
+[ci-img]: https://gitlab.com/midigator/python_opentracing_async_instrumentation/badges/master/pipeline.svg
+[ci]: https://gitlab.com/midigator/python_opentracing_async_instrumentation
+[pypi-img]: https://img.shields.io/pypi/v/opentracing_async_instrumentation.svg
+[pypi]: https://pypi.python.org/pypi/opentracing_async_instrumentation
+[cov-img]: https://gitlab.com/midigator/python_opentracing_async_instrumentation/badges/master/coverage.svg
+[cov]: https://gitlab.com/midigator/python_opentracing_async_instrumentation/badges/master/coverage.svg
+[pyver-img]: https://img.shields.io/pypi/pyversions/opentracing-async-instrumentation.svg
+[pydl-img]: https://img.shields.io/pypi/dm/opentracing-async-instrumentation.svg
+
+
+
+
+%package -n python3-opentracing-async-instrumentation
+Summary:	Async Tracing Instrumentation using OpenTracing API (http://opentracing.io)
+Provides:	python-opentracing-async-instrumentation
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-opentracing-async-instrumentation
+[![PyPI version][pypi-img]][pypi] [![Python versions][pyver-img]][pypi] [![Pypi Downloads][pydl-img]][pypi] [![Build Status][ci-img]][ci] [![Coverage Status][cov-img]][cov]
+
+
+# python-opentracing-async-instrumentation
+
+A collection of asyncio instrumentation tools to enable tracing with [OpenTracing API](http://opentracing.io).
+
+## Module
+
+Make sure you are running recent enough versions of `pip` and `setuptools`, e.g. before installing your project requirements execute this:
+
+```
+pip install --upgrade "setuptools>=29" "pip>=9"
+```
+
+The module name is `opentracing_async_instrumentation`.
+
+## What's inside
+
+### Supported client frameworks
+
+The following libraries are instrumented for tracing in this module:
+ * [aiobotocore](https://github.com/aio-libs/aiobotocore) — Asyncio AWS SDK for Python
+ * [aioboto3](https://github.com/terrycain/aioboto3) — Asyncio AWS SDK for Python (uses aiobotocore under the hood)
+ * [aiohttp](https://github.com/aio-libs/aiohttp/) - Asyncio HTTP server and client
+ * [aiomysql](https://github.com/aio-libs/aiomysql)
+
+#### Limitations
+
+ * Only Python 3.5+ is currently supported.
+
+### Server instrumentation
+
+For inbound requests a helper function `before_request` is provided for creating middleware for frameworks like aiohttp and possibly Tornado.
+
+A middleware is provided for `aiohttp`.
+
+### In-process Context Propagation
+
+As part of the OpenTracing 2.0 API, in-process `Span` propagation happens through the newly defined
+[ScopeManager](https://opentracing-python.readthedocs.io/en/latest/api.html#scope-managers)
+interface.
+
+## Usage
+
+This library provides two types of instrumentation, explicit instrumentation
+for server endpoints, and implicit instrumentation for client call sites.
+
+### Server
+
+Server endpoints are instrumented by creating a (or using a provided) middleware class that:
+
+ 1. initializes the specific tracer implementation
+ 2. wraps incoming request handlers into a method that reads the incoming
+    tracing info from the request and creates a new tracing Span
+
+```python
+from aiohttp import web
+from opentracing_async_instrumentation.client_hooks import aiohttpserver
+
+async def handler(request):
+    return web.Response(body='Hello World')
+
+app = web.Application()
+app.router.add_get('/', handler)
+app.middlewares.append(aiohttpserver.enable_tracing)
+
+if __name__ == '__main__':
+    web.run_app(app)
+```
+
+### Client
+
+Client call sites are instrumented implicitly by executing a set of
+available `client_hooks` that monkey-patch some API points in several
+common libraries like `aiohttp` and `aiobotocore`. The initialization of
+those hooks is usually also done from the middleware class's `__init__` method.
+
+Usage is via the `client_hooks` interface.
+
+```python
+from opentracing_async_instrumentation import client_hooks
+
+client_hooks.install_all_patches()
+```
+
+### Customization
+
+For the `aiohttp` library, in case you want to set custom tags
+to spans depending on content or some metadata of responses,
+you can set `response_handler_hook`.
+The hook must be a method with a signature `(response, span)`,
+where `response` and `span` are positional arguments,
+so you can use different names for them if needed.
+
+```python
+from opentracing_async_instrumentation.client_hooks.aiohttpclient import patcher
+
+
+def hook(response, span):
+    if not response.ok:
+        span.set_tag('error', 'true')
+
+
+patcher.set_response_handler_hook(hook)
+```
+
+## Development
+
+To prepare a development environment please execute the following commands.
+```bash
+virtualenv env
+source env/bin/activate
+make bootstrap
+make test
+```
+
+You can use [tox](https://tox.readthedocs.io) to run tests as well.
+```bash
+tox
+```
+
+[ci-img]: https://gitlab.com/midigator/python_opentracing_async_instrumentation/badges/master/pipeline.svg
+[ci]: https://gitlab.com/midigator/python_opentracing_async_instrumentation
+[pypi-img]: https://img.shields.io/pypi/v/opentracing_async_instrumentation.svg
+[pypi]: https://pypi.python.org/pypi/opentracing_async_instrumentation
+[cov-img]: https://gitlab.com/midigator/python_opentracing_async_instrumentation/badges/master/coverage.svg
+[cov]: https://gitlab.com/midigator/python_opentracing_async_instrumentation/badges/master/coverage.svg
+[pyver-img]: https://img.shields.io/pypi/pyversions/opentracing-async-instrumentation.svg
+[pydl-img]: https://img.shields.io/pypi/dm/opentracing-async-instrumentation.svg
+
+
+
+
+%package help
+Summary:	Development documents and examples for opentracing-async-instrumentation
+Provides:	python3-opentracing-async-instrumentation-doc
+%description help
+[![PyPI version][pypi-img]][pypi] [![Python versions][pyver-img]][pypi] [![Pypi Downloads][pydl-img]][pypi] [![Build Status][ci-img]][ci] [![Coverage Status][cov-img]][cov]
+
+
+# python-opentracing-async-instrumentation
+
+A collection of asyncio instrumentation tools to enable tracing with [OpenTracing API](http://opentracing.io).
+
+## Module
+
+Make sure you are running recent enough versions of `pip` and `setuptools`, e.g. before installing your project requirements execute this:
+
+```
+pip install --upgrade "setuptools>=29" "pip>=9"
+```
+
+The module name is `opentracing_async_instrumentation`.
+
+## What's inside
+
+### Supported client frameworks
+
+The following libraries are instrumented for tracing in this module:
+ * [aiobotocore](https://github.com/aio-libs/aiobotocore) — Asyncio AWS SDK for Python
+ * [aioboto3](https://github.com/terrycain/aioboto3) — Asyncio AWS SDK for Python (uses aiobotocore under the hood)
+ * [aiohttp](https://github.com/aio-libs/aiohttp/) - Asyncio HTTP server and client
+ * [aiomysql](https://github.com/aio-libs/aiomysql)
+
+#### Limitations
+
+ * Only Python 3.5+ is currently supported.
+
+### Server instrumentation
+
+For inbound requests a helper function `before_request` is provided for creating middleware for frameworks like aiohttp and possibly Tornado.
+
+A middleware is provided for `aiohttp`.
+
+### In-process Context Propagation
+
+As part of the OpenTracing 2.0 API, in-process `Span` propagation happens through the newly defined
+[ScopeManager](https://opentracing-python.readthedocs.io/en/latest/api.html#scope-managers)
+interface.
+
+## Usage
+
+This library provides two types of instrumentation, explicit instrumentation
+for server endpoints, and implicit instrumentation for client call sites.
+
+### Server
+
+Server endpoints are instrumented by creating a (or using a provided) middleware class that:
+
+ 1. initializes the specific tracer implementation
+ 2. wraps incoming request handlers into a method that reads the incoming
+    tracing info from the request and creates a new tracing Span
+
+```python
+from aiohttp import web
+from opentracing_async_instrumentation.client_hooks import aiohttpserver
+
+async def handler(request):
+    return web.Response(body='Hello World')
+
+app = web.Application()
+app.router.add_get('/', handler)
+app.middlewares.append(aiohttpserver.enable_tracing)
+
+if __name__ == '__main__':
+    web.run_app(app)
+```
+
+### Client
+
+Client call sites are instrumented implicitly by executing a set of
+available `client_hooks` that monkey-patch some API points in several
+common libraries like `aiohttp` and `aiobotocore`. The initialization of
+those hooks is usually also done from the middleware class's `__init__` method.
+
+Usage is via the `client_hooks` interface.
+
+```python
+from opentracing_async_instrumentation import client_hooks
+
+client_hooks.install_all_patches()
+```
+
+### Customization
+
+For the `aiohttp` library, in case you want to set custom tags
+to spans depending on content or some metadata of responses,
+you can set `response_handler_hook`.
+The hook must be a method with a signature `(response, span)`,
+where `response` and `span` are positional arguments,
+so you can use different names for them if needed.
+
+```python
+from opentracing_async_instrumentation.client_hooks.aiohttpclient import patcher
+
+
+def hook(response, span):
+    if not response.ok:
+        span.set_tag('error', 'true')
+
+
+patcher.set_response_handler_hook(hook)
+```
+
+## Development
+
+To prepare a development environment please execute the following commands.
+```bash
+virtualenv env
+source env/bin/activate
+make bootstrap
+make test
+```
+
+You can use [tox](https://tox.readthedocs.io) to run tests as well.
+```bash
+tox
+```
+
+[ci-img]: https://gitlab.com/midigator/python_opentracing_async_instrumentation/badges/master/pipeline.svg
+[ci]: https://gitlab.com/midigator/python_opentracing_async_instrumentation
+[pypi-img]: https://img.shields.io/pypi/v/opentracing_async_instrumentation.svg
+[pypi]: https://pypi.python.org/pypi/opentracing_async_instrumentation
+[cov-img]: https://gitlab.com/midigator/python_opentracing_async_instrumentation/badges/master/coverage.svg
+[cov]: https://gitlab.com/midigator/python_opentracing_async_instrumentation/badges/master/coverage.svg
+[pyver-img]: https://img.shields.io/pypi/pyversions/opentracing-async-instrumentation.svg
+[pydl-img]: https://img.shields.io/pypi/dm/opentracing-async-instrumentation.svg
+
+
+
+
+%prep
+%autosetup -n opentracing-async-instrumentation-0.2.1
+
+%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-opentracing-async-instrumentation -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Mon May 15 2023 Python_Bot <Python_Bot@openeuler.org> - 0.2.1-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..c910583
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+98c54ea864c4b9f04f9ef65c415b7471  opentracing_async_instrumentation-0.2.1.tar.gz