osprofiler package

Subpackages

Submodules

osprofiler.exc module

exception osprofiler.exc.CommandError(message: str | None = None)[source]

Bases: Exception

Invalid usage of CLI.

exception osprofiler.exc.LogInsightAPIError[source]

Bases: Exception

exception osprofiler.exc.LogInsightLoginTimeout[source]

Bases: Exception

osprofiler.initializer module

osprofiler.initializer.init_from_conf(conf: ConfigOpts, context: Any, project: str, service: str, host: str, **kwargs: Any) → None[source]

Initialize notifier from service configuration

Parameters:

  • conf – service configuration

  • context – request context

  • project – project name (keystone, cinder etc.)

  • service – service name that will be profiled

  • host – hostname or host IP address that the service will be running on.

  • kwargs – other arguments for notifier creation

osprofiler.notifier module

osprofiler.notifier.clear_notifier_cache() → None[source]
osprofiler.notifier.create(connection_string: str, *args: Any, **kwargs: Any) → Callable[[...], None][source]

Create notifier based on specified plugin_name

Parameters:

  • connection_string – connection string which specifies the storage driver for notifier

  • args – args that will be passed to the driver’s __init__ method

  • kwargs – kwargs that will be passed to the driver’s __init__ method

Returns:

Callable notifier method

osprofiler.notifier.get() → Callable[[...], None][source]

Returns notifier callable.

osprofiler.notifier.notify(info: dict[str, Any]) → None[source]

Passes the profiling info to the notifier callable.

Parameters:

info – dictionary with profiling information

osprofiler.notifier.set(notifier: Callable[[...], None]) → None[source]

Service that are going to use profiler should set callable notifier.

Callable notifier is instance of callable object, that accept exactly one argument “info”. “info” - is dictionary of values that contains profiling information.

osprofiler.opts module

osprofiler.opts.list_opts() → list[tuple[str, list[Opt]]][source]
osprofiler.opts.set_defaults(conf: ConfigOpts, enabled: bool | None = None, trace_sqlalchemy: bool | None = None, hmac_keys: str | None = None, connection_string: str | None = None, es_doc_type: str | None = None, es_scroll_time: str | None = None, es_scroll_size: int | None = None, socket_timeout: float | None = None, sentinel_service_name: str | None = None) → None[source]

osprofiler.profiler module

class osprofiler.profiler.Trace(name: str, info: dict[str, Any] | None = None)[source]

Bases: object

class osprofiler.profiler.TracedMeta(cls_name: str, bases: tuple[type, ...], attrs: dict[str, Any])[source]

Bases: type

Metaclass to comfortably trace all children of a specific class.

Possible usage:

>>>  class RpcManagerClass(object, metaclass=profiler.TracedMeta):
>>>      __trace_args__ = {'name': 'rpc',
>>>                        'info': None,
>>>                        'hide_args': False,
>>>                        'hide_result': True,
>>>                        'trace_private': False}
>>>
>>>      def my_method(self, some_args):
>>>          pass
>>>
>>>      def my_method2(self, some_arg1, some_arg2, kw=None, kw2=None)
>>>          pass

Adding of this metaclass requires to set __trace_args__ attribute to the class we want to modify. __trace_args__ is the dictionary with one mandatory key included - “name”, that will define name of action to be traced - E.g. wsgi, rpc, db, etc…

osprofiler.profiler.clean() → None[source]
osprofiler.profiler.get() → _Profiler | None[source]

Get profiler instance.

Returns:

Profiler instance or None if profiler wasn’t inited.

osprofiler.profiler.init(hmac_key: str, base_id: str | None = None, parent_id: str | None = None) → _Profiler[source]

Init profiler instance for current thread.

You should call profiler.init() before using osprofiler. Otherwise profiler.start() and profiler.stop() methods won’t do anything.

Parameters:

  • hmac_key – secret key to sign trace information.

  • base_id – Used to bind all related traces.

  • parent_id – Used to build tree of traces.

Returns:

Profiler instance

osprofiler.profiler.start(name: str, info: dict[str, Any] | None = None) → None[source]

Send new start notification if profiler instance is presented.

Parameters:

  • name – The name of action. E.g. wsgi, rpc, db, etc..

  • info – Dictionary with extra trace information. For example in wsgi it can be url, in rpc - message or in db sql - request.

osprofiler.profiler.stop(info: dict[str, Any] | None = None) → None[source]

Send new stop notification if profiler instance is presented.

osprofiler.profiler.trace(name: str, info: dict[str, Any] | None = None, hide_args: bool = False, hide_result: bool = True, allow_multiple_trace: bool = True) → Callable[[Callable[[P], R]], Callable[[P], R]][source]

Trace decorator for functions.

Very useful if you would like to add trace point on existing function:

>> @profiler.trace(“my_point”) >> def my_func(self, some_args): >> #code

Parameters:

  • name – The name of action. E.g. wsgi, rpc, db, etc..

  • info – Dictionary with extra trace information. For example in wsgi it can be url, in rpc - message or in db sql - request.

  • hide_args – Don’t push to trace info args and kwargs. Quite useful if you have some info in args that you wont to share, e.g. passwords.

  • hide_result – Boolean value to hide/show function result in trace. True - hide function result (default). False - show function result in trace.

  • allow_multiple_trace – If the wrapped function has already been traced either allow the new trace to occur or raise a value error denoting that multiple tracing is not allowed (by default allow).

osprofiler.profiler.trace_cls(name: str, info: dict[str, Any] | None = None, hide_args: bool = False, hide_result: bool = True, trace_private: bool = False, allow_multiple_trace: bool = True, trace_class_methods: bool = False, trace_static_methods: bool = False) → Callable[[T], T][source]

Trace decorator for instances of class .

Very useful if you would like to add trace point on existing method:

>> @profiler.trace_cls(“rpc”) >> RpcManagerClass(object): >> >> def my_method(self, some_args): >> pass >> >> def my_method2(self, some_arg1, some_arg2, kw=None, kw2=None) >> pass >>

Parameters:

  • name – The name of action. E.g. wsgi, rpc, db, etc..

  • info – Dictionary with extra trace information. For example in wsgi it can be url, in rpc - message or in db sql - request.

  • hide_args – Don’t push to trace info args and kwargs. Quite useful if you have some info in args that you wont to share, e.g. passwords.

  • hide_result – Boolean value to hide/show function result in trace. True - hide function result (default). False - show function result in trace.

  • trace_private – Trace methods that starts with “_”. It wont trace methods that starts “__” even if it is turned on.

  • trace_static_methods – Trace staticmethods. This may be prone to issues so careful usage is recommended (this is also why this defaults to false).

  • trace_class_methods – Trace classmethods. This may be prone to issues so careful usage is recommended (this is also why this defaults to false).

  • allow_multiple_trace – If wrapped attributes have already been traced either allow the new trace to occur or raise a value error denoting that multiple tracing is not allowed (by default allow).

osprofiler.requests module

osprofiler.requests.enable() → None[source]
osprofiler.requests.send(self: Any, request: Any, *args: Any, **kwargs: Any) → Any[source]

osprofiler.sqlalchemy module

osprofiler.sqlalchemy.add_tracing(sqlalchemy: Any, engine: Any, name: str, hide_result: bool = True) → None[source]

Add tracing to all sqlalchemy calls.

osprofiler.sqlalchemy.disable() → None[source]

Disable tracing of all DB queries. Reduce a lot size of profiles.

osprofiler.sqlalchemy.enable() → None[source]

add_tracing adds event listeners for sqlalchemy.

osprofiler.sqlalchemy.handle_error(exception_context: Any) → None[source]

Handle SQLAlchemy errors

osprofiler.sqlalchemy.wrap_session(sqlalchemy: Any, sess: Any) → Generator[Any, None, None][source]

osprofiler.web module

class osprofiler.web.WsgiMiddleware(application: WSGIApplication, hmac_keys: str | None = None, enabled: bool = False, **kwargs: Any)[source]

Bases: object

WSGI Middleware that enables tracing for an application.

classmethod factory(global_conf: dict[str, Any] | None, **local_conf: Any) → Any[source]
osprofiler.web.X_TRACE_HMAC = 'X-Trace-HMAC'

Http header that will contain the traces data hmac (that will be validated).

osprofiler.web.X_TRACE_INFO = 'X-Trace-Info'

Http header that will contain the needed traces data.

osprofiler.web.disable() → None[source]

Disable middleware.

This is the alternative way to disable middleware. It will be used to be able to disable middleware via oslo.config.

osprofiler.web.enable(hmac_keys: str | None = None) → None[source]

Enable middleware.

osprofiler.web.get_trace_id_headers() → dict[str, str][source]

Adds the trace id headers (and any hmac) into provided dictionary.

Module contents