Struct CacheKey

pub struct CacheKey(pub [u8; 32]);

Cache key derived from a request (and the current policy version).

Tuple Fields

0: [u8; 32]

Implementations

impl CacheKey

pub fn for_request(req: &AgentRequest, policy_version: u64) -> Self

Derive a key from an agent request without additional entities. Includes policy_version so a policy reload invalidates all entries.

Streams each field’s canonical JSON through the hasher, avoiding the intermediate String allocations the previous implementation made. For high-throughput PDPs (thousands of decisions/sec) this matters.

Examples

use agentguard_core::{AgentRequestBuilder, Principal, AgentAction, Resource, AgentContext};
use agentguard_core::decision::cache::CacheKey;
let req = AgentRequestBuilder::new(Principal::user("alice"))
    .action(AgentAction::tool("send_email"))
    .resource(Resource::new("Mailbox", "alice@acme"))
    .context(AgentContext::new())
    .build()
    .unwrap();
let _k = CacheKey::for_request(&req, 0);

pub fn for_request_with_entities( req: &AgentRequest, entities: &Entities, policy_version: u64, ) -> Self

Derive a key from an agent request and the complete Cedar entity set. Entity attributes and parent relationships can change a decision even when the visible request is identical, so they are part of the cache identity and are canonicalized in deterministic order.

pub fn as_hex(&self) -> String

Trait Implementations

impl Clone for CacheKey

fn clone(&self) -> CacheKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CacheKey

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

Formats the value using the given formatter.

impl Hash for CacheKey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CacheKey

fn eq(&self, other: &CacheKey) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for CacheKey

impl StructuralPartialEq for CacheKey