report_instrumentation_configuration_status `async` ¶

report_instrumentation_configuration_status(
    service: str,
    environment: str,
    configurations: InstrumentationConfigurationStatusList,
    *,
    config_overrides: Optional[AsyncApplicationSignalsClientConfig] = None,
) -> ReportInstrumentationConfigurationStatusResponse

Reports the status of one or more instrumentation configurations from SDK instances. Use this to record when configurations become ready, hit errors, become active, or are disabled by limits.

Report READY, ERROR, and DISABLED when the status changes. Report ACTIVE periodically (for example, every minute) while instrumentation is running.

Parameters:

service (str) –

The service that the reported configurations belong to.
environment (str) –

The environment that the service is running in.
configurations (InstrumentationConfigurationStatusList) –

An array of configuration status reports (up to 100) that include the instrumentation type, signal type, location hash, status, timestamp, and optional error cause.

Raises:

ThrottlingException –

The request was throttled because of quota limits.
ValidationException –

The resource is not valid.
UnknownServiceError –

The service returned an error code this client does not model.

Source code in docs_src/capo_application_signals/_services/async_application_signals.py

async def report_instrumentation_configuration_status(
    self,
    service: str,
    environment: str,
    configurations: "capo_application_signals.types.instrumentation_configuration_status_list.InstrumentationConfigurationStatusList",
    *,
    config_overrides: Optional[AsyncApplicationSignalsClientConfig] = None,
) -> "capo_application_signals.types.report_instrumentation_configuration_status_response.ReportInstrumentationConfigurationStatusResponse":
    """<p>Reports the status of one or more instrumentation configurations from SDK instances. Use this to record when configurations become ready, hit errors, become active, or are disabled by limits.</p> <p>Report <code>READY</code>, <code>ERROR</code>, and <code>DISABLED</code> when the status changes. Report <code>ACTIVE</code> periodically (for example, every minute) while instrumentation is running.</p>

    Args:
        service: <p>The service that the reported configurations belong to.</p>
        environment: <p>The environment that the service is running in.</p>
        configurations: <p>An array of configuration status reports (up to 100) that include the instrumentation type, signal type, location hash, status, timestamp, and optional error cause.</p>

    Raises:
        capo_application_signals.errors.throttling_exception.ThrottlingException: <p>The request was throttled because of quota limits.</p>
        capo_application_signals.errors.validation_exception.ValidationException: <p>The resource is not valid.</p>
        capo_application_signals.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_application_signals.types.report_instrumentation_configuration_status_request.ReportInstrumentationConfigurationStatusRequest]",
    ) -> AsyncOperationResponse[
        "capo_application_signals.types.report_instrumentation_configuration_status_response.ReportInstrumentationConfigurationStatusResponse"
    ]:
        import capo_application_signals._operations.application_signals.report_instrumentation_configuration_status

        (
            output,
            http_response,
        ) = await capo_application_signals._operations.application_signals.report_instrumentation_configuration_status.async_report_instrumentation_configuration_status(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides,
        OperationLogging("ReportInstrumentationConfigurationStatus"),
    )
    input_: capo_application_signals.types.report_instrumentation_configuration_status_request.ReportInstrumentationConfigurationStatusRequest = {
        "service": service,
        "environment": environment,
        "configurations": configurations,
    }

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output

report_instrumentation_configuration_status async ¶

report_instrumentation_configuration_status `async` ¶