Struct JsonSlicer 

pub struct JsonSlicer { /* private fields */ }

Condenses JSON responses.

Example

use boundgraph_slice::{JsonSlicer, MemoryStore, Raw, Slicer};

let body = serde_json::json!({
    "users": (0..5_000).map(|i| serde_json::json!({ "id": i })).collect::<Vec<_>>(),
    "api_key": "sk-live-do-not-leak-this",
});

let condensate = tokio::runtime::Builder::new_current_thread()
    .build()?
    .block_on(JsonSlicer::new().condense(
        &Raw::new(body.to_string()),
        300,
        &MemoryStore::new(),
    ))?;

let payload = format!("{:?}", condensate.payload);
assert!(!payload.contains("do-not-leak-this"), "the key never reaches the model");

Implementations

impl JsonSlicer

pub fn new() -> Self

A slicer sampling three array elements and four levels deep.

pub fn sampling(self, elements: usize, max_depth: usize) -> Self

Sample this many array elements, and elide below this depth.

pub fn redacting<S: Into<String>>( self, keys: impl IntoIterator<Item = S>, ) -> Self

Treat these field names as secret too, on top of the built-in list.

For a response whose credential field is called something nobody would guess. The built-in list is not replaced — narrowing it is not offered, because the cost of the two mistakes is not symmetric.

Trait Implementations

impl Clone for JsonSlicer

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for JsonSlicer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for JsonSlicer

fn default() -> Self

Returns the “default value” for a type.

impl Slicer for JsonSlicer

fn id(&self) -> SlicerId

Which slicer this is, and at what version.

fn slice<'life0, 'life1, 'async_trait>( &'life0 self, raw: &'life1 Raw, cap: usize, ) -> Pin<Box<dyn Future<Output = Result<Slice, SliceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Produce the summary. The part an implementation writes.

fn counter(&self) -> &dyn TokenCount

How this slicer counts tokens.

fn minimum_cap(&self) -> usize

The least a summary from this slicer can cost.

fn condense<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, raw: &'life1 Raw, cap: usize, store: &'life2 dyn Store, ) -> Pin<Box<dyn Future<Output = Result<Condensate, SliceError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Preserve the original, slice it, and check the result fits.