Struct FrameworkRequestFailure 

pub struct FrameworkRequestFailure<E, D = BoundedDiagnostic> { /* private fields */ }

Only the actual context-bound source submission above constructs this value. No Clone, Default, From, raw identity constructor, or context replacement.

use saddle_observability::FrameworkRequestFailure;
fn naked() -> Result<(), FrameworkRequestFailure<u32>> { Err(17) }

use saddle_observability::FrameworkRequestFailure;
fn bypass() -> Result<(), FrameworkRequestFailure<u32>> {
    let value: Result<(), u32> = Err(17);
    value?;
    Ok(())
}

use saddle_observability::FrameworkRequestFailure;
fn forged(source: FrameworkRequestFailure<u32>) -> FrameworkRequestFailure<u32> {
    FrameworkRequestFailure { error: 17, ..source }
}

Implementations

impl<E, D> FrameworkRequestFailure<E, D>

pub fn error(&self) -> &E

Examples found in repository

examples/early_request_diagnostic.rs (line 50)

fn main() {
    // Caller is at the accepted socket phase; no trace, span, request or task is
    // fabricated to satisfy a constructor. The output may genuinely be absent.
    let scope =
        RequestDiagnosticScope::early(None, EarlyRequestContext::socket_accepted("example"))
            .with_phase(DiagnosticRequestPhase::ReadingHead);
    let failure = match read_head(&mut io::empty(), &scope) {
        Err(failure) => failure,
        Ok(()) => panic!("owned empty reader must fail"),
    };
    let id = failure.source_diagnostic().id();
    let (retained, delivery) = failure.finish_boundary_retained(
        None,
        &DiagnosticOutcomeAxes {
            operation: OperationOutcome::Failed,
            ..Default::default()
        },
    );
    assert_eq!(retained.error().kind(), io::ErrorKind::UnexpectedEof);
    assert_eq!(retained.source_diagnostic().id(), id);
    assert_eq!(
        delivery.source_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    assert_eq!(
        delivery.boundary_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    // Real consumer keeps `retained` in its task/response result, not just bool.
    println!("GO: early source retained without invented identities or output");
}

examples/outbound_child_diagnostic.rs (line 72)

fn main() {
    let observer = Observer::with_writer(ObserverConfig::default(), std::io::sink()).unwrap();
    let (incoming, _) = observer
        .start_external_call_with_rpc(
            "shop",
            "ingress",
            "orders",
            "query",
            Some("gateway-opaque"),
            RpcCorrelationId::new("0.3").unwrap(),
        )
        .unwrap();
    let ingress_event = EventContext::new(
        RequestIdentity::new("request-7").unwrap(),
        RouteIdentity::new("/incoming").unwrap(),
        1,
    )
    .unwrap();
    let parent = RequestDiagnosticScope::output_unavailable(incoming.context(), &ingress_event)
        .with_task(DiagnosticTaskId::from_runtime_id("42").unwrap())
        .unwrap_or_else(|_| panic!("task"))
        .with_zone(DiagnosticZone::from_validated_ingress("zone-a").unwrap());

    // programming.rs generates the wire child; Boundary uses its trace/rpc plus
    // request_id/function. The adapter below does NOT generate these identities.
    let wire_trace = "gateway-opaque";
    let wire_rpc = "0.3.1";
    let request_id = "request-7";
    let function = "remote.query";
    let (root, _) = observer
        .start_external_call_with_rpc(
            "saddle",
            "zone-a",
            "profusecontract",
            "invoke",
            Some(wire_trace),
            RpcCorrelationId::new(wire_rpc).unwrap(),
        )
        .unwrap();
    let event = EventContext::new(
        RequestIdentity::new(request_id).unwrap(),
        RouteIdentity::new(function).unwrap(),
        1,
    )
    .unwrap();
    let child = parent
        .derive_outbound_child(root.context(), &event)
        .unwrap();
    let failure = child.fail(
        std::io::ErrorKind::ConnectionRefused,
        DiagnosticCategory::UnexpectedError,
        BoundedDiagnosticCause::new(
            DiagnosticStage::RequestDecode,
            DiagnosticCode::new("outbound.connect_failed").unwrap(),
        ),
    );
    let id = failure.source_diagnostic().id();
    let (retained, delivery) =
        failure.finish_boundary_retained(None, &DiagnosticOutcomeAxes::default());
    assert_eq!(retained.source_diagnostic().id(), id);
    assert_eq!(*retained.error(), std::io::ErrorKind::ConnectionRefused);
    assert_eq!(
        delivery.source_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    assert_eq!(
        delivery.boundary_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    println!("GO: Boundary-shaped child Call/Event consumed; absent output retains same failure");
}

pub fn submission(&self) -> DiagnosticSubmission

pub fn map_error<F>( self, map: impl FnOnce(E) -> F, ) -> FrameworkRequestFailure<F, D>

pub fn record_boundary( &self, output: &EmergencyDiagnosticHandle, axes: &DiagnosticOutcomeAxes, ) -> DiagnosticSubmission

pub fn record_boundary_optional( &self, output: Option<&EmergencyDiagnosticHandle>, axes: &DiagnosticOutcomeAxes, ) -> DiagnosticSubmission

pub fn finish_boundary_retained( self, output: Option<&EmergencyDiagnosticHandle>, axes: &DiagnosticOutcomeAxes, ) -> (Self, BoundaryDiagnosticDelivery)

Declared terminal observation without discarding the original error or diagnostic on missing/full/closed output. The returned SAME mandatory carrier must remain in the enclosing result until its actual terminal. This does not prove that arbitrary Rust drop/forget can be forbidden.

Examples found in repository

examples/early_request_diagnostic.rs (lines 43-49)

fn main() {
    // Caller is at the accepted socket phase; no trace, span, request or task is
    // fabricated to satisfy a constructor. The output may genuinely be absent.
    let scope =
        RequestDiagnosticScope::early(None, EarlyRequestContext::socket_accepted("example"))
            .with_phase(DiagnosticRequestPhase::ReadingHead);
    let failure = match read_head(&mut io::empty(), &scope) {
        Err(failure) => failure,
        Ok(()) => panic!("owned empty reader must fail"),
    };
    let id = failure.source_diagnostic().id();
    let (retained, delivery) = failure.finish_boundary_retained(
        None,
        &DiagnosticOutcomeAxes {
            operation: OperationOutcome::Failed,
            ..Default::default()
        },
    );
    assert_eq!(retained.error().kind(), io::ErrorKind::UnexpectedEof);
    assert_eq!(retained.source_diagnostic().id(), id);
    assert_eq!(
        delivery.source_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    assert_eq!(
        delivery.boundary_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    // Real consumer keeps `retained` in its task/response result, not just bool.
    println!("GO: early source retained without invented identities or output");
}

examples/outbound_child_diagnostic.rs (line 70)

fn main() {
    let observer = Observer::with_writer(ObserverConfig::default(), std::io::sink()).unwrap();
    let (incoming, _) = observer
        .start_external_call_with_rpc(
            "shop",
            "ingress",
            "orders",
            "query",
            Some("gateway-opaque"),
            RpcCorrelationId::new("0.3").unwrap(),
        )
        .unwrap();
    let ingress_event = EventContext::new(
        RequestIdentity::new("request-7").unwrap(),
        RouteIdentity::new("/incoming").unwrap(),
        1,
    )
    .unwrap();
    let parent = RequestDiagnosticScope::output_unavailable(incoming.context(), &ingress_event)
        .with_task(DiagnosticTaskId::from_runtime_id("42").unwrap())
        .unwrap_or_else(|_| panic!("task"))
        .with_zone(DiagnosticZone::from_validated_ingress("zone-a").unwrap());

    // programming.rs generates the wire child; Boundary uses its trace/rpc plus
    // request_id/function. The adapter below does NOT generate these identities.
    let wire_trace = "gateway-opaque";
    let wire_rpc = "0.3.1";
    let request_id = "request-7";
    let function = "remote.query";
    let (root, _) = observer
        .start_external_call_with_rpc(
            "saddle",
            "zone-a",
            "profusecontract",
            "invoke",
            Some(wire_trace),
            RpcCorrelationId::new(wire_rpc).unwrap(),
        )
        .unwrap();
    let event = EventContext::new(
        RequestIdentity::new(request_id).unwrap(),
        RouteIdentity::new(function).unwrap(),
        1,
    )
    .unwrap();
    let child = parent
        .derive_outbound_child(root.context(), &event)
        .unwrap();
    let failure = child.fail(
        std::io::ErrorKind::ConnectionRefused,
        DiagnosticCategory::UnexpectedError,
        BoundedDiagnosticCause::new(
            DiagnosticStage::RequestDecode,
            DiagnosticCode::new("outbound.connect_failed").unwrap(),
        ),
    );
    let id = failure.source_diagnostic().id();
    let (retained, delivery) =
        failure.finish_boundary_retained(None, &DiagnosticOutcomeAxes::default());
    assert_eq!(retained.source_diagnostic().id(), id);
    assert_eq!(*retained.error(), std::io::ErrorKind::ConnectionRefused);
    assert_eq!(
        delivery.source_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    assert_eq!(
        delivery.boundary_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    println!("GO: Boundary-shaped child Call/Event consumed; absent output retains same failure");
}

pub fn source_diagnostic(&self) -> &D

Examples found in repository

examples/early_request_diagnostic.rs (line 42)

fn main() {
    // Caller is at the accepted socket phase; no trace, span, request or task is
    // fabricated to satisfy a constructor. The output may genuinely be absent.
    let scope =
        RequestDiagnosticScope::early(None, EarlyRequestContext::socket_accepted("example"))
            .with_phase(DiagnosticRequestPhase::ReadingHead);
    let failure = match read_head(&mut io::empty(), &scope) {
        Err(failure) => failure,
        Ok(()) => panic!("owned empty reader must fail"),
    };
    let id = failure.source_diagnostic().id();
    let (retained, delivery) = failure.finish_boundary_retained(
        None,
        &DiagnosticOutcomeAxes {
            operation: OperationOutcome::Failed,
            ..Default::default()
        },
    );
    assert_eq!(retained.error().kind(), io::ErrorKind::UnexpectedEof);
    assert_eq!(retained.source_diagnostic().id(), id);
    assert_eq!(
        delivery.source_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    assert_eq!(
        delivery.boundary_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    // Real consumer keeps `retained` in its task/response result, not just bool.
    println!("GO: early source retained without invented identities or output");
}

examples/outbound_child_diagnostic.rs (line 68)

fn main() {
    let observer = Observer::with_writer(ObserverConfig::default(), std::io::sink()).unwrap();
    let (incoming, _) = observer
        .start_external_call_with_rpc(
            "shop",
            "ingress",
            "orders",
            "query",
            Some("gateway-opaque"),
            RpcCorrelationId::new("0.3").unwrap(),
        )
        .unwrap();
    let ingress_event = EventContext::new(
        RequestIdentity::new("request-7").unwrap(),
        RouteIdentity::new("/incoming").unwrap(),
        1,
    )
    .unwrap();
    let parent = RequestDiagnosticScope::output_unavailable(incoming.context(), &ingress_event)
        .with_task(DiagnosticTaskId::from_runtime_id("42").unwrap())
        .unwrap_or_else(|_| panic!("task"))
        .with_zone(DiagnosticZone::from_validated_ingress("zone-a").unwrap());

    // programming.rs generates the wire child; Boundary uses its trace/rpc plus
    // request_id/function. The adapter below does NOT generate these identities.
    let wire_trace = "gateway-opaque";
    let wire_rpc = "0.3.1";
    let request_id = "request-7";
    let function = "remote.query";
    let (root, _) = observer
        .start_external_call_with_rpc(
            "saddle",
            "zone-a",
            "profusecontract",
            "invoke",
            Some(wire_trace),
            RpcCorrelationId::new(wire_rpc).unwrap(),
        )
        .unwrap();
    let event = EventContext::new(
        RequestIdentity::new(request_id).unwrap(),
        RouteIdentity::new(function).unwrap(),
        1,
    )
    .unwrap();
    let child = parent
        .derive_outbound_child(root.context(), &event)
        .unwrap();
    let failure = child.fail(
        std::io::ErrorKind::ConnectionRefused,
        DiagnosticCategory::UnexpectedError,
        BoundedDiagnosticCause::new(
            DiagnosticStage::RequestDecode,
            DiagnosticCode::new("outbound.connect_failed").unwrap(),
        ),
    );
    let id = failure.source_diagnostic().id();
    let (retained, delivery) =
        failure.finish_boundary_retained(None, &DiagnosticOutcomeAxes::default());
    assert_eq!(retained.source_diagnostic().id(), id);
    assert_eq!(*retained.error(), std::io::ErrorKind::ConnectionRefused);
    assert_eq!(
        delivery.source_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    assert_eq!(
        delivery.boundary_submission(),
        DiagnosticSubmission::OutputUnavailable
    );
    println!("GO: Boundary-shaped child Call/Event consumed; absent output retains same failure");
}

pub fn finish_boundary( self, output: &EmergencyDiagnosticHandle, axes: &DiagnosticOutcomeAxes, ) -> (E, BoundaryDiagnosticDelivery)

Sole consuming release of the original error: records its boundary first. The enclosing component must use this only at its declared public boundary, not as an adapter back to a legacy internal technical-failure path.

impl<D> FrameworkRequestFailure<(), D>

pub fn into_reference(self) -> RequestBoundaryReference<D>

Consume a capture receipt into its context-preserving boundary reference.