def _uninstrument():
"""Disables instrumenting for all newly created ClientSessions"""
unwrap(aiohttp.ClientSession, "__init__")
def _uninstrument(self, **kwargs):
unwrap(
import_module(self._wrapped_module_name),
self._wrapped_function_name,
)
def _uninstrument() -> None:
"""Disables instrumenting for all newly created Client and AsyncClient instances"""
unwrap(httpx.Client, "send")
unwrap(httpx.AsyncClient, "send")
def _uninstrument(self, **kwargs):
unwrap(tornado.web.RequestHandler, "__init__")
unwrap(tornado.httpclient.AsyncHTTPClient, "fetch")
for handler in self.patched_handlers:
unpatch_handler_class(handler)
self.patched_handlers = []
def _uninstrument(self, **kwargs):
if redis.VERSION < (3, 0, 0):
unwrap(redis.StrictRedis, "execute_command")
unwrap(redis.StrictRedis, "pipeline")
unwrap(redis.Redis, "pipeline")
unwrap(
redis.client.BasePipeline, # pylint:disable=no-member
"execute",
)
unwrap(
redis.client.BasePipeline, # pylint:disable=no-member
"immediate_execute_command",
)
else:
unwrap(redis.Redis, "execute_command")
unwrap(redis.Redis, "pipeline")
unwrap(redis.client.Pipeline, "execute")
unwrap(redis.client.Pipeline, "immediate_execute_command")
def _uninstrument(self, **kwargs):
unwrap(sqlalchemy, "create_engine")
unwrap(sqlalchemy.engine, "create_engine")
def _uninstrument(self, **kwargs):
if kwargs.get("channel_type") == "secure":
unwrap(grpc, "secure_channel")
else:
unwrap(grpc, "insecure_channel")
def _uninstrument(self, **kwargs):
unwrap(BaseClient, "_make_api_call")
unwrap(Endpoint, "prepare_request")
def _uninstrument(self, **kwargs):
unwrap(BaseClient, "_make_api_call")
def _uninstrument(self, **kwargs):
unwrap(sqlalchemy, "create_engine")
unwrap(sqlalchemy.engine, "create_engine")
if parse_version(sqlalchemy.__version__).release >= (1, 4):
unwrap(sqlalchemy.ext.asyncio, "create_async_engine")
def _uninstrument():
unwrap(http.client.HTTPConnection, "send")
unwrap(http.client.HTTPConnection, "connect")
def _uninstrument_exchange():
unwrap(Exchange, "publish")
def _uninstrument_queue():
unwrap(Queue, "consume")
def _uninstrument_client(
client: typing.Union[httpx.Client, httpx.AsyncClient]) -> None:
"""Disables instrumentation for the given Client or AsyncClient"""
# pylint: disable=protected-access
unwrap(client, "send")
def _uninstrument(self, **kwargs):
""" "Disable Pyramid instrumentation"""
unwrap(Configurator, "__init__")
def _uninstrument(self, **kwargs: Dict[str, Any]) -> None:
unwrap(boto3, "client")
for client_cls in botocore.client.BaseClient.__subclasses__():
self._un_decorate_sqs(client_cls)
def _uninstrument(self, **kwargs: Dict[str, Any]) -> None:
if hasattr(self, "__opentelemetry_tracer_provider"):
delattr(self, "__opentelemetry_tracer_provider")
unwrap(BlockingConnection, "channel")
def _uninstrument(self, **kwargs):
for ctype in self._which_channel(kwargs):
unwrap(grpc, ctype)
def _uninstrument(self, **kwargs):
unwrap(grpc, "server")
def unwrap_connect():
"""Disable integration with aiopg library.
https://github.com/aio-libs/aiopg
"""
unwrap(aiopg, "connect")
def _uninstrument(self, **kwargs):
for command in COMMANDS:
unwrap(pymemcache.client.base.Client, "{}".format(command))
def unwrap_create_pool():
"""Disable integration with aiopg library.
https://github.com/aio-libs/aiopg
"""
unwrap(aiopg, "create_pool")
def _uninstrument(self, **kwargs):
unwrap(elasticsearch.Transport, "perform_request")
def _uninstrument(self, **kwargs):
unwrap(AWSQueryConnection, "make_request")
unwrap(AWSAuthConnection, "make_request")
def _uninstrument(self, **kwargs):
unwrap(kafka.KafkaProducer, "send")
unwrap(kafka.KafkaConsumer, "__next__")
def _uninstrument(self, **kwargs):
unwrap(jinja2.Template, "render")
unwrap(jinja2.Template, "generate")
unwrap(jinja2.Environment, "compile")
unwrap(jinja2.Environment, "_load_template")
def _uninstrument():
unwrap(urllib3.connectionpool.HTTPConnectionPool, "urlopen")
def _uninstrument(self, **kwargs):
for command in COMMANDS:
unwrap(pymemcache.client.base.Client, f"{command}")