Struct ExecutionLogging 

pub(crate) struct ExecutionLogging {
    guard: Option<StatementLoggingGuard>,
    coordinator_must_not_run: bool,
}

The session task’s slot for the end-of-execution obligation of the statement it is running. One slot is held for the whole SessionClient::execute call and there is exactly one retirement site.

An empty slot means no log entry exists for this execution, so a fallback to the coordinator lets it begin its own. An occupied slot means the session task owes an end event: Self::retire pays it, Self::release transfers it to the coordinator. Self::id returning None covers both “not sampled” and “the end is logged elsewhere”, which want identical treatment everywhere.

Fields

guard: Option<StatementLoggingGuard>

coordinator_must_not_run: bool

Whether the coordinator must not run this statement, because the session task has already counted it in the metrics Coordinator::handle_execute maintains. Handing it over afterwards would count it twice.

Implementations

impl ExecutionLogging

pub(crate) fn adopt( outer: Option<ExecuteContextGuard>, peek_client: &PeekClient, ) -> Self

Adopts the end-of-execution obligation of an outer statement (a FETCH or an EXECUTE running its inner statement), or starts out empty when there is no outer statement.

pub(crate) fn id(&self) -> Option<StatementLoggingId>

Returns the logging id, if an end event is owed and the statement is being logged.

pub(crate) fn take_over( &mut self, peek_client: &PeekClient, session: &mut Session, stmt: Option<&Statement<Raw>>, params: &Params, logging: &Arc<QCell<PreparedStatementLoggingInfo>>, catalog: &Catalog, lifecycle_timestamps: Option<LifecycleTimestamps>, taking_over: TakeOver, ) -> Option<StatementLoggingId>

Records that the session task, not the coordinator, is executing stmt. Bumps the counters Coordinator::handle_execute would have bumped and makes sure a log entry exists, inheriting the adopted one if there is one. stmt is None for an empty portal, which is logged but not counted.

For TakeOver::StatementToRun, every exit after this call must produce an outcome for the statement: the coordinator will not see it.

fn begin_or_inherit( &mut self, peek_client: &PeekClient, session: &mut Session, params: &Params, logging: &Arc<QCell<PreparedStatementLoggingInfo>>, catalog: &Catalog, lifecycle_timestamps: Option<LifecycleTimestamps>, )

Makes sure a log entry exists for this execution, keeping an adopted one if there is one.

pub(crate) fn release(&mut self) -> Option<ExecuteContextExtra>

Hands the obligation to the coordinator, which retires it once the statement it dispatches finishes. None tells the coordinator to begin its own entry, Some with no id inside tells it that an entry already exists or that sampling declined.

pub(crate) fn retire(self, result: &Result<ExecuteResponse, AdapterError>)

Emits the end event for result, if we still owe one.

pub(crate) fn defuse(&mut self)

Leaves the slot inert, for dispatch sites that hand the end of execution to the coordinator or the protocol layer (registered peeks, subscribes).