Ravensight

What each page is for

The sidebar is grouped by what you are doing rather than by which database the answer comes from. The order below is the order the sidebar puts them in.

Build

Project-scoped: these read the title, not one of its builds.

  • Brainstorm. A board of cards beside a partner that has read your studio's own findings, patterns, touchpoints and sales. See Brainstorm.
  • Design. Your design documents, and a chat that has read your studio's findings before it proposes an edit. See Design studio.
  • Code scan. What your code reports against what your telemetry actually receives. See Source scan.
  • Playtest. Jobs, briefs, findings and reports from AI personas playing your build. See Playtest.

Live data

Environment-scoped: every number here comes from the events one build sent. Overview, Player insights and Events each carry a Real players select, because persona sessions are real rows in the same store and are excluded by default.

  • Overview. Daily active players, top events, lifetime totals, retention, the level funnel and the implementation health card. Pick 7 or 14 days and a By hour chart shows active players for each hour (UTC), with no point for an hour that had no events; hours need a window of at most 14 days. Results are cached per scope and range, so a repeat visit does not re-run the warehouse queries; a missing or expired snapshot still fetches fresh.
  • Player insights. A triage board of the sessions the backend flagged, with the plain-language signals behind each call. See how the detections read your events. A spread card shows how session length, events per session, sessions per player or playtime per player is distributed: the mean, median, 90th percentile, smallest and largest, and a histogram of 5 to 50 buckets.
  • Events. Raw events newest first, filterable by name and paged, with expandable payload rows.
  • Funnels. An ordered sequence of two to eight event names: who reached each step, how many were lost against the step before, and the average and median gap into each one. Each conversion shows the count behind it and a 95% range, and a funnel with fewer than 30 at step one is marked as a small sample, so a dozen players never read as a precise percentage. Count players or sessions, and filter by an event property: either only the step events that carry it, or whole sessions that touched it, which is what you want when only one step sends the property.
  • Retention. How many players come back, by the day (or week) they first played. Pick up to nine days from day 0 to day 90 and see a curve and a cohort table, each cell with its rate and its count. Classic counts a player who came back on that exact day; rolling counts one who came back on that day or any later one. A start event makes a player's first day their first occurrence of it, and a return event counts only it as coming back; either is an event name, or kind:purchase (and the like) for a typed kind: a bare purchase is your own event of that name. A typed event stored with rs_invalid is never counted. A day a cohort has not lived through yet reads not yet, never zero. Turn on cumulative figures for each cohort's sessions, playtime and revenue per currency. Daily, weekly and monthly active players and stickiness (daily over monthly) sit above. The Overview keeps its day 1 and day 7 tiles and links here. Split it by the build, platform, country, device model, OS version or GPU players started on, or the first value they sent of a property: the five biggest values and the rest, each with its count and a 95% range, because a retention figure for a dozen players is a wide range.
  • Level map. Where deaths, or any event you name, happen in a level: a grid of counts from the x and y numbers your events carry as top-level properties, for example Ravensight.track_event("player_died", {"level": "room_4", "x": 412, "y": 96, "rs_kind": "death"}), or under other property names you choose. Each spot lists its events and its players, because one player dying twenty times is a different finding from twenty players dying once, and the page says how many events had no position. You can pick an image of your level to draw the map over; it stays in your browser and is never uploaded, and you give it the coordinates its corners stand for. The map assumes y grows downward, as in Godot 2D.
  • Why it moved. How much a number changed between two equal windows, whether a change that size could be chance, and where it sits: by platform, build, level, new or returning and your top properties. Open it from an anomaly on Alerts and it compares that day with the same weekday a week earlier. It says where a change sits, not why; the link at the top asks Huginn, at its normal price. It covers players, new players, sessions, average session, events, errors, errors per session and progression failures. Revenue is not split here, because money stays per currency.
  • Builds. Did your patch help: two values of game_version side by side. Day 1 and day 7 retention follow the players who started on each build, and a return on any build counts. Players who hit an error, median session and frame rate read what happened on the build, and you can name a funnel to run on each. Every number shows what it rests on and a 95% range. A reading needs 10 on each side and says "not enough data" below that; under 30 a number is marked as a small sample. With several measures on one page one can look clear by chance alone, so confirm a surprise before acting on it.
  • Monetization. What players spent, from purchase events (rs_kind: "purchase"): paying conversion, payers, first purchases and the time to a first purchase, then one currency at a time its revenue, transactions, revenue per paying player and per daily active player, a daily chart, a histogram of revenue per paying player and the top items. Amounts stay in their own currency and are never converted or added across currencies; a purchase stored with rs_invalid is never counted. Below them, ads and total revenue: ads shown, clicked and rewarded, ads per session, purchases plus ad revenue per currency, revenue per player and per daily player, and ads by placement, network or format. Ad revenue keeps its fractions of a cent.
  • Acquisition. Where players came from and what each campaign returned. Installs come from attribution events; revenue is what those players spent in the window, purchases and ads; spend is what you import from a daily CSV export (a date, a campaign and the amount, with its currency; importing the same file again updates the same rows). Revenue is credited to the campaign on the player's latest event. Return on spend is revenue over spend in one currency, and a campaign with no spend imported says so rather than showing zero. Players whose attribution named no campaign count as installs, but their revenue is not measured. Spend, return on spend and this page are for your own studio only: a studio you share a game with can read the campaign columns and value per player by campaign through its analytics, never your spend. A forecast of value per player, by day 30 to 365 with a likely range, is fitted on what players have spent so far and is labelled as a forecast, because events are kept 90 days and later days are an extrapolation.
  • Campaign links. Make a tracked link to your store page or any https address, share it, and count the people who follow it, by source, campaign, link, device and day. It needs no code in your game. A click is a referral click, never a conversion. See campaign links.
  • Progression. How players move through your own hierarchy, from progression events (rs_p1, rs_p2, rs_p3 name a world, a level and a stage). Start at the top level and open a row to look one level deeper, with attempts, completes, fails, players, the win rate (completes over completes plus fails), the median time from a session's first start to its first completion and the median rs_score. A place that only has fails still appears in the Overview level funnel, with a fails count. A progression event stored with rs_invalid is never counted.
  • Economy. The virtual currencies your game creates and removes, from resource events (rs_resource names the currency, rs_flow is source or sink, rs_amount is how much). Every resource lists what was earned and spent, the net, the players who earned and the players who spent. Pick one to see a daily earned, spent and net chart and the items that drained or filled it most. Amounts are the game's own units, not money, and a resource event stored with rs_invalid is never counted.
  • Health. The errors your game reports and how it performs. Send error events (rs_severity is debug, info, warning, error or critical, and rs_message is cut to 200 characters) and health events (rs_fps_median, rs_fps_p10, rs_memory_mb and rs_boot_ms, each optional). You see the errors per affected player, a daily chart per severity, the most frequent messages (open a row for the whole message) and the builds that raise them against their sessions. Performance is one sample per session, the latest it sent, grouped by platform and build with the median and slowest-tenth frame rate, memory and boot time, plus sessions per frame rate bucket. The Hardware card groups the same samples, and the share of sessions that raised an error, by device model, OS version or GPU (see country and device), and suggests a minimum spec: the groups whose median is under 30 frames per second or where more than 5% of sessions hit an error, judged only on groups with 20 or more sessions that sent a health sample, and for OS versions the lowest version per platform from which every version meets that target. An event stored with rs_invalid is never counted. The Data quality card below shows how late events arrive (an hour or more; a game that queues offline is late by design), duplicates dropped at ingest and repeats stored past it, what changed in event names and top-level keys between your two most recently seen builds, which SDKs sent in the last 24 hours and what ingest refused this month.
  • Journeys. The level-to-level graph, where players stop, churn-heavy transitions, loops and estimated common paths. Only on deployments with journey graphs configured.
  • Player Reports. The inbox for what players sent from inside the game. See Player Reports. A game without the report overlay sees its free-form feedback here instead, summarized by sentiment and theme and searchable by meaning.

Understand

  • Studio Intelligence. An investigation that ties a question to its evidence to a decision. See Studio Intelligence.
  • Huginn (AI analyst). Ask in plain English; Huginn picks its own read-only tools and answers with the numbers it used. Conversations are listable, resumable, renameable and deletable. See Huginn, the AI analyst.
  • Muninn (studio memory). What your studio has learned: one game's facts and the patterns that cite it, or under All games, every game's. See Muninn, studio memory.

Studio

  • Marketing. What you did outside the game and the lift the platform measured afterwards. See Marketing memory.
  • Sales. Its own page directly below Marketing in the Studio navigation. Record what each title earned, filter the ledger, compare totals by currency, explore a 90 day launch curve, and import store exports. See the Sales ledger.

Settings sits below the groups rather than inside them, because it is global to the account rather than to the selected game. Its tabs are Usage and billing and Payment history (both owner only), Projects, Team, Huginn, MCP access, Playtest CLI and Appearance. Settings also links to the audit log, who did what in the org, for owners and admins. The usage meter beside it, titled Events, shows this month's total against the included events on one bar, split into the share your games' player events and reports sent and the share MCP calls count as, with a line under the bar for each. For the owner, a prepaid balance extends the figure to an estimate: the included events plus what the balance covers at the event rate, though the balance is shared with AI units, playtests and scans. The bar turns amber at 80 percent, and hovering the meter gives the totals and the overage so far.

How the built-in detections read your events

The level funnel, journeys, and the player flags are computed from your event names and the place fields, with no configuration. Name your events accordingly and they light up.

  • Deaths are events whose name contains died, destroyed, or killed (lowercase substring match, so player_died and ship_destroyed both count).
  • Level starts are names containing start, begin, or enter; completions contain complet, finish, win, or clear.
  • An explicit rs_kind comes first. Set rs_kind in the event data to level_start, level_complete, death, or none and the level funnel, per-level deaths, journeys and the death count read it before the name. none opts an event out, so checkout_started with rs_kind: "none" is not a level start. An unknown value falls through to the name match. The five typed kinds are known values too, so a purchase is never read as a level by its name, and a progression event is read by its rs_status. Keys that start with rs_ are reserved for Ravensight. The rage quit rules below read it too.
  • level, location and track fold into one place. The first non-empty one wins, in that order. The funnel, per-level deaths, and journeys only see events that have a place. It is any string that names a place or mode in your game: a level id, an encounter, a scene name. An event with a place that is not a level start, completion or death is navigation only: it stays out of the funnel and is counted as place_without_kind on the Implementation health card, unless it sends rs_kind: "none".
  • Rage quit likely flags a session with 3 or more deaths in its last 5 events, 3 or more deaths at the same level, or a final death followed by more than 10 minutes of silence inside the queried window. A death here is an event sent with rs_kind: "death", whatever its name, so a run_ended event with rs_kind: "death" counts. Without a known rs_kind, the first two read died/destroyed names and the last reads a name containing died; rs_kind: "none" is never a death.
  • Potentially stuck flags a session that repeats one event 10 or more times at the same level while the whole session has fewer than 20 events. The same event at a new level each time is movement, not stuck. Events with no place are grouped together, so ten repeats of a placeless event in a short session count; send a place or accept it.
  • Highly engaged flags a session with at least 20 events at more than 2 events per minute and fewer than 5 deaths.

Every flag comes back with the plain-language indicators that triggered it, so you can always see why a session was tagged.

Worked examples

Each example is one session, read under the default detection profile (a death is a failure, rage quit on, no terminal events), with every event inside the queried window. The outcome is what the code computes, word for word where it writes an indicator.

Level start

1  game_started    {}
2  level_started   {"level": "cavern-1"}
3  boss_entered    {"level": "cavern-1"}
4  shop_entered    {"level": "cavern-1", "rs_kind": "none"}
5  level_started   {}

The level funnel shows cavern-1 with 2 starts: line 2, and line 3, because boss_entered contains enter. Line 4 would match too, but rs_kind: "none" opts it out. Lines 1 and 5 are level starts by name (game_started contains start) but carry no place, so the funnel never sees them. With no completion, cavern-1 reads 0 percent complete.

Level complete

1  level_started   {"level": "1-1"}
2  level_complete  {"level": "1-1"}
3  level_started   {"track": "1-2"}
4  stage_cleared   {"location": "1-2"}
5  window_opened   {"level": "1-2"}

1-1: 1 start, 1 completion, 100 percent. 1-2: 1 start (line 3, where track is the place) and 2 completions, line 4 (cleared contains clear, and location is the place) and line 5, because window_opened contains win. Two completions against one start is a completion rate of 2, so send line 5 with rs_kind: "none".

Death

1  level_started   {"level": "boss"}
2  player_died     {"level": "boss"}
3  ship_destroyed  {"level": "boss"}
4  enemy_killed    {"level": "boss"}
5  run_ended       {"level": "boss", "rs_kind": "death"}

The session's death count is 4, and the funnel shows boss with 1 start, 0 completions and 4 deaths: lines 2, 3 and 4 by name, line 5 by its rs_kind. Line 4 is the trap: enemy_killed contains killed, so an enemy's death counts as the player's unless it is sent with rs_kind: "none". The rage quit rules read only died and destroyed names (plus rs_kind: "death"), so for them lines 2, 3 and 5 are deaths and line 4 is not; that is 3 deaths in the last 5 events and 3 at boss, so this session is also flagged rage quit likely.

Rage quit

1  level_started   {"level": "3"}
2  player_died     {}
3  player_died     {}
4  hint_shown      {}
5  player_died     {}

Flagged rage quit likely with the indicator 3 deaths in last 5 events. The same place rule does not fire: deaths with no place are left out of it, so a placeless death is never counted as being at any place. Sent with {"level": "3"}, the same three deaths would add 3 deaths at same location (3). The last event is a death whose name contains died, so a query whose window ends more than 10 minutes after line 5 also adds Session ended immediately after death (Nmin ago), with N the whole minutes since that event; a last event named ship_destroyed would not, because that rule reads only died names and rs_kind: "death".

Stuck

1  level_started   {"level": "ledge"}
2  jump_failed     {"level": "ledge"}   sent 10 times
3  hint_shown      {}
4  jump_failed     {}                   sent 4 times
5  game_exited     {}

17 events in all. Flagged potentially stuck with the indicator Repeating same action: jump_failed (10x). The rule is one event name repeated 10 or more times at one place, in a session of fewer than 20 events (19 at most). Repeats are counted per event name and place, and events with no place share one group of their own: the 4 placeless jump_failed on line 4 are counted apart from the 10 at ledge, and had all 14 been sent without a place they would have counted as 14 at that one placeless group. Three more events of any kind would make 20, and the session would not be flagged.

The detection profile

The rules above assume dying is failing and a level ends in a completion. Some games are built the other way round, so each game has a detection profile, set on the game's card under Settings > Projects by an owner or an admin and saved through a confirmation. It has three settings:

  • A death is a failure or an outcome. Failure is the default. Choose outcome when dying is how a run normally ends, as in a roguelike: a death then counts as an intended end of the run, a completion in the level funnel, and never as a death, a rage quit signal or a reason a session is not engaged.
  • Rage quit detection on or off. Off, the flag is not computed at all and each session row answers rageQuitLikely: null rather than false, so the dashboard says detection is off instead of showing zero. Every rage rule reads deaths, so deaths as outcomes also stop rage quit being inferred.
  • Terminal events. Up to 20 event names, 1 to 200 characters each, that end a run on purpose, such as run_summary or credits_shown. They count as completions, never as starts or deaths, and never as the action the stuck rule looks for.

Every flag is inferred, and the answers say so. The session list (and the MCP tool query_players) carries inferred: true and sample_sessions, the number of sessions the flags were inferred from, and the overview carries detection: { profile, sample_sessions }. The dashboard labels a flag or a count with its sample, and a count of zero reads "No flags inferred from N sessions", never as players being fine. The profile is also readable and writable at GET and PUT /api/v1/games/:gameId/settings/detection, where the PUT body is any subset of death_kind, rage_quit and terminal_events.

Typed events: purchases, resources, progression, errors, health, ads and attribution

Seven more rs_kind values give an event a fixed meaning: purchase, resource, progression, error, health, ad and attribution. Each one has a small contract of reserved rs_ keys, sent at the top level of the event data next to your own properties. Any other key you send is stored as usual.

rs_kindRequired keysOptional keys
purchasers_amount (whole minor units: an integer or a string of up to 15 digits), rs_currency (three-letter ISO 4217 code), rs_item_type and rs_item_id (1 to 100 characters)rs_cart (up to 100 characters), rs_transaction_id (up to 128)
resourcers_flow (source or sink), rs_resource (1 to 64 characters), rs_amount (a plain number of zero or more)rs_item_type and rs_item_id (1 to 100 characters each when sent; the economy page shows a missing one as no item)
progressionrs_status (start, complete or fail), rs_p1 (1 to 100 characters)rs_p2, rs_p3 (rs_p3 needs rs_p2), rs_score (a number)
errorrs_severity (debug, info, warning, error or critical), rs_message (stored up to 200 characters)rs_stack (stored up to 2,000 characters), rs_source, rs_error_type (up to 100 characters), rs_trail (stored up to 1,500 characters); see error capture
healthAt least one of rs_fps_median, rs_fps_p10, rs_memory_mb, rs_boot_ms, each a number of zero or moreThe other three
adrs_ad_network (1 to 64 characters), rs_ad_format (banner, interstitial, rewarded, native, app_open or other), rs_ad_result (shown, clicked, failed or rewarded)rs_ad_placement (1 to 100 characters), rs_revenue_micros (a string of up to 18 digits) with rs_currency (three-letter ISO 4217 code, required with revenue)
attributionrs_attr_source (1 to 64 characters, for example utm or organic)rs_attr_network (up to 100 characters), rs_campaign, rs_adset and rs_creative (up to 200 characters each), rs_touch_time (epoch milliseconds)
  • Money is whole minor units. A purchase of 4.99 US dollars is "rs_amount": 499, "rs_currency": "USD"; 500 yen is 500 with JPY. A decimal such as 4.99 breaks the contract rather than being rounded. The currency is stored upper-cased, and totals are never added across currencies. A repeated transaction id is counted once: resending a purchase with the same rs_transaction_id from the same device is one purchase in every report, while a purchase with no transaction id always counts on its own. Do not send a purchase when a store restores one the player already owns, only for a new transaction.
  • Ad revenue is whole micros. One ad impression is often worth a fraction of a cent, so ad revenue has its own key: rs_revenue_micros is millionths of one unit of rs_currency, sent as a string of digits. 0.0015 US dollars is "rs_revenue_micros": "1500", "rs_currency": "USD". A decimal such as 0.0015 breaks the contract. Send revenue on the shown event, the paid impression, and send clicked, rewarded and failed without it: revenue on any other result breaks the contract.
  • Attribution is recorded once per device. Send one attribution event when a player first installs or lands. The first one for a device is kept, and every later event from that device carries its campaign, adset and creative, so revenue can be credited to the campaign that brought the player. A browser game can read its landing page's UTM parameters and send them this way.
  • Resource amounts are plain numbers, not money: 12.5 gold is fine. rs_flow says which way it moved, so the amount is never negative: spending 5 gold is "rs_flow": "sink", "rs_amount": 5. A negative amount breaks the contract and is left out of the economy report.
  • Progression feeds the level funnel. A start counts as a level start, a complete as a completion, and a fail in the funnel's fails column. An event with no level, location or track is placed at its nodes joined with /, so rs_p1: "world_1", rs_p2: "stage_2" is the place world_1/stage_2.
  • Send health once per session, as a summary near its end, rather than once per frame or per minute.
  • Accepted and flagged, never refused. An event that breaks its contract is still stored and still answers 202. The server adds rs_invalid with the broken rule (for example purchase_amount), every typed report leaves the event out (a flagged progression event is not a start, completion or fail in the level funnel), and it is counted as typed_event_invalid on the Implementation health card. The 202 body then carries invalid, the number of such events in the request; when there are none the body is exactly { "accepted": n }. The 8 KB data limit is measured on what you send, before rs_invalid is added. Only the server writes rs_invalid: one your game sends is dropped from the stored event and counted as rs_key_unknown.