> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.hoop.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Session Recording

> Record and playback terminal sessions and entire database resource roles.

export const RiskMetricsAnimation = () => {
  const METRICS = [{
    label: 'Queries redacted',
    target: 1247,
    color: 'var(--warm-gold)'
  }, {
    label: 'Operations blocked',
    target: 38,
    color: 'var(--warm-gold)'
  }, {
    label: 'Sessions analyzed',
    target: 8934,
    color: 'rgba(var(--sand-100-rgb),0.6)'
  }, {
    label: 'Approval requests',
    target: 156,
    color: 'rgba(var(--sand-100-rgb),0.6)'
  }];
  const COUNT_DURATION = 2000;
  const HOLD_DURATION = 3000;
  const CYCLE_DURATION = COUNT_DURATION + HOLD_DURATION;
  function easeOutCubic(t) {
    return 1 - Math.pow(1 - t, 3);
  }
  const [values, setValues] = useState(METRICS.map(() => 0));
  const [cycle, setCycle] = useState(0);
  const raf = useRef(null);
  const timers = useRef([]);
  useEffect(() => {
    timers.current.forEach(clearTimeout);
    timers.current = [];
    if (raf.current) cancelAnimationFrame(raf.current);
    setValues(METRICS.map(() => 0));
    const start = performance.now();
    function tick(now) {
      const elapsed = now - start;
      const progress = Math.min(elapsed / COUNT_DURATION, 1);
      const eased = easeOutCubic(progress);
      setValues(METRICS.map(m => Math.round(eased * m.target)));
      if (progress < 1) {
        raf.current = requestAnimationFrame(tick);
      }
    }
    raf.current = requestAnimationFrame(tick);
    const resetId = setTimeout(() => setCycle(c => c + 1), CYCLE_DURATION);
    timers.current.push(resetId);
    return () => {
      if (raf.current) cancelAnimationFrame(raf.current);
      timers.current.forEach(clearTimeout);
    };
  }, [cycle]);
  const styles = {
    root: {
      position: 'relative',
      width: '100%'
    },
    mock: {
      borderRadius: 12,
      overflow: 'hidden',
      border: '1px solid rgba(var(--sand-100-rgb),0.08)',
      background: 'linear-gradient(135deg, var(--gradient-dark-start) 0%, var(--gradient-dark-mid) 60%, var(--gradient-dark-end) 100%)'
    },
    toolbar: {
      display: 'flex',
      justifyContent: 'space-between',
      alignItems: 'center',
      padding: '10px 16px',
      borderBottom: '1px solid rgba(var(--sand-100-rgb),0.06)'
    },
    dots: {
      display: 'flex',
      gap: 6
    },
    dot: {
      width: 8,
      height: 8,
      borderRadius: '50%',
      background: 'rgba(var(--sand-100-rgb),0.10)'
    },
    title: {
      fontFamily: 'var(--mono)',
      fontSize: 11,
      color: 'rgba(var(--sand-100-rgb),0.2)'
    },
    grid: {
      display: 'grid',
      gridTemplateColumns: '1fr 1fr',
      gap: 1,
      background: 'rgba(var(--sand-100-rgb),0.04)'
    },
    card: {
      padding: 20,
      display: 'flex',
      flexDirection: 'column',
      gap: 4,
      background: 'rgba(var(--sand-100-rgb),0.02)'
    },
    value: {
      fontFamily: 'var(--display)',
      fontSize: 28,
      fontWeight: 700,
      letterSpacing: '-0.02em',
      lineHeight: 1
    },
    label: {
      fontFamily: 'var(--sans)',
      fontSize: 11,
      color: 'rgba(var(--sand-100-rgb),0.3)',
      marginBottom: 8
    },
    barTrack: {
      height: 3,
      background: 'rgba(var(--sand-100-rgb),0.06)',
      borderRadius: 2,
      overflow: 'hidden'
    },
    barFill: {
      height: '100%',
      borderRadius: 2,
      transition: 'width 0.1s linear',
      opacity: 0.6
    },
    status: {
      display: 'flex',
      alignItems: 'center',
      gap: 7,
      padding: '10px 16px',
      borderTop: '1px solid rgba(var(--sand-100-rgb),0.06)',
      fontFamily: 'var(--sans)',
      fontSize: 11,
      color: 'rgba(var(--sand-100-rgb),0.25)'
    },
    statusDot: {
      width: 6,
      height: 6,
      borderRadius: '50%',
      background: 'var(--warm-gold)'
    }
  };
  return <div style={styles.root} aria-hidden="true">
      <div style={styles.mock}>
        <div style={styles.toolbar}>
          <div style={styles.dots}>
            <div style={styles.dot} />
            <div style={styles.dot} />
            <div style={styles.dot} />
          </div>
          <span style={styles.title}>hoop · risk dashboard</span>
          <span style={{
    width: 48
  }} />
        </div>

        <div style={styles.grid}>
          {METRICS.map((m, i) => <div key={m.label} style={styles.card}>
              <span style={{
    ...styles.value,
    color: m.color
  }}>
                {values[i].toLocaleString()}
              </span>
              <span style={styles.label}>{m.label}</span>
              <div style={styles.barTrack}>
                <div style={{
    ...styles.barFill,
    width: `${values[i] / m.target * 100}%`,
    background: m.color
  }} />
              </div>
            </div>)}
        </div>

        <div style={styles.status}>
          <span style={styles.statusDot} />
          <span>Live · last 30 days</span>
        </div>
      </div>
    </div>;
};

<div style={{background: 'linear-gradient(135deg, #111111 0%, #1A1A1A 35%, #2A2A2A 70%, #3A3A3A 100%)', borderRadius: 14, overflow: 'hidden', padding: 24, height: 300}}>
  <RiskMetricsAnimation />
</div>

You can audit tracks every action made with Hoop.dev. It provides video recordings of sessions and logging.

## Benefits

**Faster Debugging**: Quickly identify what went wrong in a session with complete visibility into every command and response. Which means there is no need to reconstruct issues from memory or incomplete logs.

**Streamlined Compliance**: Automatically generate detailed audit trails to support SOC 2, HIPAA, and PCI compliance without setting up external log forwarding or managing multiple logging systems.

**Improved Onboarding and Knowledge Sharing**: Session recordings double as live documentation, helping new team members learn how experienced engineers navigate complex systems.

**Zero-Trust Security Enforcement**: Maintain full visibility into how access is used. Every action is tied to an authenticated user, with no standing credentials or untracked activity.

## Key Features

**Complete Session Capture:** Includes precise timestamps, user identity with organizational context, and resource role metadata for every session.

**Full Input/Output Recording:** Records every command entered and response returned, with optional high-definition video playback and structured log export.

**Searchable Metadata:** Sessions are enriched with tags and contextual information for fast filtering, retrieval, and analysis.

**Multiple Output Formats:** View sessions as videos in the browser or export structured logs for automated processing and reporting.

## Information available

**Time**: start and end time of each session

**User**: complete user information inside your organization

**Resource Role**: the resource role used in the session

**Input and Output**: every command and its output an user has executed

* **Video recording**: a video recording of the session
* **Logs**: a log of the session

**Capture every interaction with full visibility, faster troubleshooting, and built-in compliance.**

[Hoop.dev](http://Hoop.dev)’s session recording feature provides a complete, searchable record of user activity across your infrastructure—without disrupting developer workflows.

***

## How it Works

**Transparent Proxy Layer:** [hoop.dev](http://hoop.dev) sits between users and infrastructure, capturing all session data without changing your existing tools or workflows.

**Automatic Recording:** Session recording starts the moment a user connects through [hoop.dev](http://hoop.dev). There’s no manual setup or toggling required.

**Structured Storage and Search:** Recorded sessions are stored securely with rich metadata, making it easy to search by user, resource, or timeframe.

**Security and Access Controls:** Session data is protected by role-based access controls and integrated into your existing permission model.

***

## Getting Started

1. **Connect Resources:** Add your databases, Kubernetes clusters, or infrastructure endpoints to [hoop.dev](http://hoop.dev) using the appropriate connection strings and credentials.
2. **Enable Session Recording:** Turn on session recording globally or per-resource-role. Use granular policies to define what gets recorded and for how long.
3. **Invite Team Members:** Add users and assign access permissions. All activity is automatically tracked and tied to each individual.
4. **Use Existing Workflows:** Developers can continue using their preferred CLI or web interface. [hoop.dev](http://hoop.dev) captures sessions in the background—no workflow changes needed.

***

**Session recording turns everyday infrastructure access into a rich source of insight, accountability, and operational efficiency.**

For reliability engineering, security, and compliance teams, it’s a simple way to ensure visibility without slowing anyone down.