sys.monitoring — Execution event monitoring

Added in version 3.12.

Note

sys.monitoring is a namespace within thesys module,not an independent module, so there is no need toimportsys.monitoring, simplyimportsys and then usesys.monitoring.

This namespace provides access to the functions and constants necessary toactivate and control event monitoring.

As programs execute, events occur that might be of interest to tools thatmonitor execution. Thesys.monitoring namespace provides means toreceive callbacks when events of interest occur.

The monitoring API consists of three components:

Tool identifiers

A tool identifier is an integer and the associated name.Tool identifiers are used to discourage tools from interfering with eachother and to allow multiple tools to operate at the same time.Currently tools are completely independent and cannot be used tomonitor each other. This restriction may be lifted in the future.

Before registering or activating events, a tool should choose an identifier.Identifiers are integers in the range 0 to 5 inclusive.

Registering and using tools

sys.monitoring.use_tool_id(tool_id:int,name:str,/)→None

Must be called beforetool_id can be used.tool_id must be in the range 0 to 5 inclusive.Raises aValueError iftool_id is in use.

sys.monitoring.free_tool_id(tool_id:int,/)→None

Should be called once a tool no longer requirestool_id.

Note

free_tool_id() will not disable global or local events associatedwithtool_id, nor will it unregister any callback functions. Thisfunction is only intended to be used to notify the VM that theparticulartool_id is no longer in use.

sys.monitoring.get_tool(tool_id:int,/)→str|None

Returns the name of the tool iftool_id is in use,otherwise it returnsNone.tool_id must be in the range 0 to 5 inclusive.

All IDs are treated the same by the VM with regard to events, but thefollowing IDs are pre-defined to make co-operation of tools easier:

sys.monitoring.DEBUGGER_ID=0sys.monitoring.COVERAGE_ID=1sys.monitoring.PROFILER_ID=2sys.monitoring.OPTIMIZER_ID=5

Events

The following events are supported:

sys.monitoring.events.BRANCH

A conditional branch is taken (or not).

sys.monitoring.events.CALL

A call in Python code (event occurs before the call).

sys.monitoring.events.C_RAISE

An exception raised from any callable, except for Python functions (event occurs after the exit).

sys.monitoring.events.C_RETURN

Return from any callable, except for Python functions (event occurs after the return).

sys.monitoring.events.EXCEPTION_HANDLED

An exception is handled.

sys.monitoring.events.INSTRUCTION

A VM instruction is about to be executed.

sys.monitoring.events.JUMP

An unconditional jump in the control flow graph is made.

sys.monitoring.events.LINE

An instruction is about to be executed that has a different line number from the preceding instruction.

sys.monitoring.events.PY_RESUME

Resumption of a Python function (for generator and coroutine functions), except forthrow() calls.

sys.monitoring.events.PY_RETURN

Return from a Python function (occurs immediately before the return, the callee’s frame will be on the stack).

sys.monitoring.events.PY_START

Start of a Python function (occurs immediately after the call, the callee’s frame will be on the stack)

sys.monitoring.events.PY_THROW

A Python function is resumed by athrow() call.

sys.monitoring.events.PY_UNWIND

Exit from a Python function during exception unwinding.

sys.monitoring.events.PY_YIELD

Yield from a Python function (occurs immediately before the yield, the callee’s frame will be on the stack).

sys.monitoring.events.RAISE

An exception is raised, except those that cause aSTOP_ITERATION event.

sys.monitoring.events.RERAISE

An exception is re-raised, for example at the end of afinally block.

sys.monitoring.events.STOP_ITERATION

An artificialStopIteration is raised; seethe STOP_ITERATION event.

More events may be added in the future.

These events are attributes of thesys.monitoring.events namespace.Each event is represented as a power-of-2 integer constant.To define a set of events, simply bitwise OR the individual events together.For example, to specify bothPY_RETURN andPY_STARTevents, use the expressionPY_RETURN|PY_START.

sys.monitoring.events.NO_EVENTS

An alias for0 so users can do explicit comparisons like:

ifget_events(DEBUGGER_ID)==NO_EVENTS:...

Events are divided into three groups:

Local events

Local events are associated with normal execution of the program and happenat clearly defined locations. All local events can be disabled.The local events are:

Ancillary events

Ancillary events can be monitored like other events, but are controlledby another event:

TheC_RETURN andC_RAISE eventsare controlled by theCALL event.C_RETURN andC_RAISE events will only be seen if thecorrespondingCALL event is being monitored.

Other events

Other events are not necessarily tied to a specific location in theprogram and cannot be individually disabled.

The other events that can be monitored are:

The STOP_ITERATION event

PEP 380specifies that aStopIteration exception is raised when returning a valuefrom a generator or coroutine. However, this is a very inefficient way toreturn a value, so some Python implementations, notably CPython 3.12+, do notraise an exception unless it would be visible to other code.

To allow tools to monitor for real exceptions without slowing down generatorsand coroutines, theSTOP_ITERATION event is provided.STOP_ITERATION can be locally disabled, unlikeRAISE.

Turning events on and off

In order to monitor an event, it must be turned on and a corresponding callbackmust be registered.Events can be turned on or off by setting the events either globally orfor a particular code object.

Setting events globally

Events can be controlled globally by modifying the set of events being monitored.

sys.monitoring.get_events(tool_id:int,/)→int

Returns theint representing all the active events.

sys.monitoring.set_events(tool_id:int,event_set:int,/)→None

Activates all events which are set inevent_set.Raises aValueError iftool_id is not in use.

No events are active by default.

Per code object events

Events can also be controlled on a per code object basis. The functionsdefined below which accept atypes.CodeType should be preparedto accept a look-alike object from functions which are not definedin Python (seeMonitoring C API).

sys.monitoring.get_local_events(tool_id:int,code:CodeType,/)→int

Returns all the local events forcode

sys.monitoring.set_local_events(tool_id:int,code:CodeType,event_set:int,/)→None

Activates all the local events forcode which are set inevent_set.Raises aValueError iftool_id is not in use.

Local events add to global events, but do not mask them.In other words, all global events will trigger for a code object,regardless of the local events.

Disabling events

sys.monitoring.DISABLE

A special value that can be returned from a callback function to disableevents for the current code location.

Local events can be disabled for a specific code location by returningsys.monitoring.DISABLE from a callback function. This does not changewhich events are set, or any other code locations for the same event.

Disabling events for specific locations is very important for highperformance monitoring. For example, a program can be run under adebugger with no overhead if the debugger disables all monitoringexcept for a few breakpoints.

sys.monitoring.restart_events()→None

Enable all the events that were disabled bysys.monitoring.DISABLEfor all tools.

Registering callback functions

To register a callable for events call

sys.monitoring.register_callback(tool_id:int,event:int,func:Callable|None,/)→Callable|None

Registers the callablefunc for theevent with the giventool_id

If another callback was registered for the giventool_id andevent,it is unregistered and returned.Otherwiseregister_callback() returnsNone.

Functions can be unregistered by callingsys.monitoring.register_callback(tool_id,event,None).

Callback functions can be registered and unregistered at any time.

Registering or unregistering a callback function will generate asys.audit() event.

Callback function arguments

sys.monitoring.MISSING

A special value that is passed to a callback function to indicatethat there are no arguments to the call.

When an active event occurs, the registered callback function is called.Different events will provide the callback function with different arguments, as follows:

  • PY_START andPY_RESUME:

    func(code:CodeType,instruction_offset:int)->DISABLE|Any

  • PY_RETURN andPY_YIELD:

    func(code:CodeType,instruction_offset:int,retval:object)->DISABLE|Any

  • CALL,C_RAISE andC_RETURN:

    func(code:CodeType,instruction_offset:int,callable:object,arg0:object|MISSING)->DISABLE|Any

    If there are no arguments,arg0 is set tosys.monitoring.MISSING.

  • RAISE,RERAISE,EXCEPTION_HANDLED,PY_UNWIND,PY_THROW andSTOP_ITERATION:

    func(code:CodeType,instruction_offset:int,exception:BaseException)->DISABLE|Any

  • LINE:

    func(code:CodeType,line_number:int)->DISABLE|Any

  • BRANCH andJUMP:

    func(code:CodeType,instruction_offset:int,destination_offset:int)->DISABLE|Any

    Note that thedestination_offset is where the code will next execute.For an untaken branch this will be the offset of the instruction followingthe branch.

  • INSTRUCTION:

    func(code:CodeType,instruction_offset:int)->DISABLE|Any