Introducing Pixel-Perfect Session Replay

You Can't Fix What You Can't See

Every support ticket has a story behind it. A user clicked a button that didn't respond. A form submitted but nothing happened. A page loaded with the layout completely broken on their device. You read the ticket, check the logs, and try to reproduce the issue on your machine. It works fine. Sound familiar?

Session replay changes the equation entirely. Instead of guessing what happened, you watch it happen. Every click, scroll, form interaction, and page transition is reconstructed in a pixel-perfect recording that shows you exactly what the user experienced.

Today, we're launching session replay in JustAnalytics -- and it's built with privacy as a first principle.

How It Works

JustAnalytics session replay captures the DOM structure of your page and records incremental mutations as the user interacts. This isn't a video recording. It's a lightweight stream of DOM snapshots and diffs that we reconstruct in the dashboard player.

The result is a faithful reproduction of the user's experience, including:

• Page transitions and route changes (including SPA navigation)
• Scroll depth and viewport position
• Click targets with element attribution
• Form interactions (with input masking by default)
• Network requests and their timing
• Console errors that occurred during the session
• CSS and layout changes including responsive breakpoints

Session Replay is On by Default

Session replay is built into the monitor.js script and is enabled by default at a 10% sample rate with mask-all privacy. Just add the script -- no extra attributes needed:

<!-- Replay is automatically enabled (10% sample, mask-all privacy) -->
<script
  defer
  src="https://justanalytics.app/monitor.js"
  data-site-id="YOUR_SITE_ID"
/>

To disable replay, add data-replay="false". Or configure it programmatically:

JustAnalytics.init({
  siteId: 'YOUR_SITE_ID',
  replay: {
    enabled: true,
    sampleRate: 0.5,        // Record 50% of sessions
    maskAllInputs: true,     // Default: mask all form inputs
    maskAllText: false,      // Optional: mask all text content
    blockSelectors: ['.sensitive-data', '#credit-card'],
  },
});

The replay payload adds roughly 20-40KB per minute of session activity, compressed and batched to minimize network overhead.

Privacy First: Default Masking and GDPR Compliance

We believe session replay should be useful and respectful of user privacy. That's why JustAnalytics takes a privacy-first approach where sensitive data is masked by default, not opt-in.

What's Masked by Default

• All form inputs -- text fields, password fields, textareas, and select dropdowns show placeholder dots instead of actual values
• Credit card numbers -- detected and masked regardless of input masking settings
• Email addresses -- automatically detected in text nodes and replaced with [email]

Granular Privacy Controls

You have full control over what gets recorded:

JustAnalytics.init({
  siteId: 'YOUR_SITE_ID',
  replay: {
    enabled: true,
    // Mask everything - maximum privacy
    maskAllText: true,
    maskAllInputs: true,
    // Block specific elements entirely (replaced with placeholder)
    blockSelectors: [
      '.user-avatar',
      '.private-message',
      '[data-sensitive]',
    ],
    // Ignore specific elements (not recorded at all)
    ignoreSelectors: [
      '.ad-banner',
      '.third-party-widget',
    ],
  },
});

You can also use HTML attributes directly on elements:

<!-- This element will be blocked from recording -->
<div data-ja-block>
  Sensitive content here
</div>

<!-- This input will be masked -->
<input type="text" data-ja-mask />

<!-- This element will be ignored entirely -->
<div data-ja-ignore>
  Not relevant to recording
</div>

GDPR and CCPA Compliance

Session replay in JustAnalytics is designed for compliance:

• No cookies required -- replay data is tied to anonymous session identifiers
• Do Not Track respected -- if the user has DNT enabled, no replay data is collected
• Data retention controls -- set how long replay data is stored (7, 14, 30, or 90 days)
• Right to deletion -- replay data can be purged per session or per user identifier
• EU data residency -- available for teams on the Business plan

Frustration Signals: Rage Clicks and Dead Clicks

Watching every session recording would take forever. That's why we built automatic frustration detection that surfaces the sessions that matter most.

Rage Clicks

A rage click is detected when a user clicks the same element three or more times within two seconds. This almost always indicates that something isn't working as expected -- a button that doesn't respond, a link that looks clickable but isn't, or a UI element that's broken.

JustAnalytics automatically tags sessions with rage clicks and surfaces them in a dedicated Frustration Signals panel:

• Element identification -- which element was rage-clicked, including CSS selector and text content
• Frequency -- how many rage click events occurred in the session
• Context -- what happened before and after the rage click (network errors, console errors, page transitions)

Dead Clicks

Dead clicks occur when a user clicks an element that has no resulting action -- no navigation, no network request, no DOM change. These are subtler than rage clicks but equally important:

• Buttons with missing event handlers
• Links with href="#" or broken routes
• Interactive-looking elements that aren't actually interactive
• Disabled buttons without visual disabled state

Frustration Scoring

Each session receives a frustration score from 0 to 100 based on:

Signal	Weight
Rage clicks	30 points per occurrence
Dead clicks	15 points per occurrence
JavaScript errors	20 points per error
Long page loads (>3s)	10 points
Rapid back-and-forth navigation	10 points per occurrence

Sessions with high frustration scores appear at the top of your replay list, so you can focus on the experiences that need attention most.

Heatmaps and Click Maps

Session replay data powers two additional visualization tools that help you understand user behavior at scale.

Click Maps

Click maps aggregate click data across all sessions to show you where users click most on any page. Each click is represented as a point on the page, with density indicating frequency.

Click maps answer questions like:

• Which CTAs get the most engagement?
• Are users clicking on non-interactive elements?
• Is the navigation hierarchy working as intended?
• Are important elements being overlooked?

Scroll Heatmaps

Scroll heatmaps show you how far users scroll on each page, with color gradients indicating the percentage of users who reached each depth:

• Red zone (top) -- 100% of users see this content
• Yellow zone -- 50-75% of users scroll this far
• Blue zone -- 25-50% of users reach here
• Cold zone (bottom) -- less than 25% of users see this

This is critical for content-heavy pages, landing pages, and long-form articles where content placement directly impacts conversion.

Filtering Heatmaps

Heatmaps can be filtered by:

• Date range -- compare behavior across time periods
• Device type -- desktop vs mobile vs tablet
• Traffic source -- organic vs paid vs direct
• Country -- geographic segments
• Custom segments -- any segment you've defined in JustAnalytics

Connecting Replay to Errors and Traces

One of the most powerful aspects of having session replay in the same platform as error tracking and APM is automatic correlation.

Error Context

When a JavaScript error occurs during a recorded session, the error detail page in JustAnalytics includes a Watch Replay button that jumps directly to the moment the error happened. You see:

• What the user was doing in the 30 seconds before the error
• The exact DOM state when the error fired
• Network requests that preceded the error
• Console output leading up to the failure

This eliminates the "works on my machine" problem. You see exactly what the user saw.

Trace Correlation

For full-stack applications using the Node.js SDK, session replay connects to server-side traces. If a user clicks a button that triggers an API call that times out, you can:

1. Watch the replay to see the user experience
2. Click through to the associated trace
3. See the server-side span that timed out
4. Identify the database query or external service call that caused the delay

This end-to-end visibility is something that requires three or four separate tools in most monitoring stacks.

How It Compares to LogRocket

LogRocket is the market leader in session replay, and for good reason -- it's a mature, feature-rich product. Here's how JustAnalytics session replay compares:

Feature	JustAnalytics	LogRocket
DOM-based replay	Yes	Yes
Input masking	Default on	Opt-in
Rage click detection	Yes	Yes
Dead click detection	Yes	Yes
Heatmaps	Yes	Yes
Click maps	Yes	Yes
Error correlation	Yes	Yes
APM trace correlation	Yes	Via integration
Network request capture	Yes	Yes
Console log capture	Yes	Yes
Custom masking rules	Yes	Yes
Pricing	Included in plan	$99/mo+
Separate JavaScript snippet	No	Yes

The key difference is integration. With LogRocket, session replay is a standalone product that you integrate with your error tracker and APM tool. With JustAnalytics, it's part of the same platform, sharing the same session context, the same error groups, and the same trace IDs. There's no integration step because there's nothing to integrate.

Performance Impact

Session replay adds minimal overhead to your application:

• Script size increase: ~8KB gzipped (added to the base tracker.js)
• CPU overhead: less than 1% on modern devices (MutationObserver-based capture)
• Network usage: 20-40KB/min compressed, batched every 5 seconds
• Memory: approximately 5-10MB for typical sessions

We've tested session replay on low-end Android devices, older iPhones, and Chromebooks. The performance impact is negligible in all cases.

Sampling for High-Traffic Sites

For sites with millions of sessions per month, you can configure sampling to control costs:

JustAnalytics.init({
  siteId: 'YOUR_SITE_ID',
  replay: {
    enabled: true,
    sampleRate: 0.1,  // Record 10% of sessions
    // Always record sessions with errors, regardless of sample rate
    errorSampleRate: 1.0,
  },
});

With errorSampleRate: 1.0, every session that encounters a JavaScript error will be recorded even if it falls outside the general sample rate. This ensures you always have replay context for debugging.

Getting Started

Session replay is available today on all JustAnalytics plans and is enabled by default when you add monitor.js. To get started:

1. Add the monitor.js script -- replay starts automatically at 10% sample rate with mask-all privacy
2. Review privacy settings in your site's Settings > Session Replay panel
3. Adjust your sample rate if needed (default is 10%)
4. Watch your first replay in the Dashboard > Session Replay section

There's no additional installation, no separate snippet, no extra attributes, and no extra billing. Session replay is part of JustAnalytics.

Start your 7-day free trial and see what your users see.