Sending Game Data as Event Logs: Sending Event Logs, Part 3

Collecting Actual Game Actions as Data

"Validating Your Collection Structure and Metrics with Test Logs: Sending Event Logs, Part 2" covered how to send test logs to validate an event's collection structure and metric setup. This part covers how to apply the validated event structure to the actual game and send actual data at the moment a player's action occurs.

Even after you have confirmed event names, properties, data types, and value formats with test logs, the actual game must run the log-sending code at the moment the player's action occurs. Apply the code where actions such as content completion, currency acquisition, or item use are confirmed, and connect the actual game data at that moment to the event properties.

If an event is sent too early, actions that were never completed may be counted. If it is sent too late, the log may be lost to a screen transition or the app closing. Decide the sending timing based on what the event means, and send the log right after the actual action is completed.

Sending Event Logs in Hive Analytics

Hive Analytics event logs can be sent from the game client or from a server. Client sending supports Unity, Unreal Engine, C++, Android, and iOS development environments, and servers can send event logs using Fluentd or HTTP.

An event log consists of required properties needed for normal collection and processing, and custom properties that describe the details of the event.

The required properties include the following values that identify the player and device, the app and project (game), the event name, and when it occurred.

Rules for Sending Required Properties
If the required properties do not meet the following rules, the event is not collected normally and is stored in the quarantine table t_raw_event_log_rescue.

• A required property is missing or sent as an empty value
• An appId that is not registered in the Hive Console is sent
• A required property name is sent in snake case, such as user_id
• eventTime is not in RFC 3339 format including the time zone
• eventTime is outside the allowed range of 10 years in the past to 5 years in the future from the current time

Required property names must be sent in camel case or lowercase. For quarantined logs, check the raw data and the quarantine reason in t_raw_event_log_rescue, correct the wrong values, and send them again.

Custom properties can be freely configured to analyze the details of an event, such as character level, content type, score, and play time. Both clients and servers connect actual game values to the custom properties needed for analysis and send them directly.

Sending a Content Completion Event with contents_success

This section applies the contents_success event to the actual game. Send the event when a player completes game content, and connect the content type, the player's status, and the play results to actual game data.

Check When to Send the Event

contents_success is an event that occurs when game content is completed. Send it right after the completion result is confirmed through a server response or game logic, not when the player enters the content or starts playing.

If the same completion handling can run more than once during retries or screen transitions, make sure the event is not sent multiple times for a single action.

Connect Custom Properties

Check the properties predefined for contents_success and connect the actual game data at the moment the event occurred to each property.

Keep property names, data types, and value units the same as the criteria you validated with test logs. For time-related properties such as playTimeSec in particular, use a single unit, such as seconds or milliseconds, so that data from multiple games (projects) can be analyzed on the same basis.

Configure the Required Properties

An event log must include the required properties userId, deviceId, identifierProvider, appId, appIdGroup, eventTime, and eventName.

When you send from the client with Hive SDK v4, all required properties except eventName are collected automatically. Properties that describe the player's app and runtime environment, such as market, hive_country, language, os, and app_version, are also collected, so you only configure eventName yourself among the required properties.

When you send from the client with Hive Axyl, identifierProvider is fixed to hive on the server, and appId is automatically passed in the log-sending request header using the value specified when the SDK was initialized. Configure and send the other required properties yourself.

When sending from a server, configure the required properties yourself for both Fluentd and HTTP. For details on how to send, see Event Transmission on the Hive Developers site.

Apply the Event-Sending Code

In Data > Event, select contents_success and go to the Source Generation tab. Select the client or server development method and the game's development environment, and check the generated source code.

Developers replace the sample values in the generated source code with actual game variables and apply the code where content completion is confirmed. Enter contents_success as the event name, and pass the characterLv, modeTypeId, modeTypeName, score, and playTimeSec values at the time of content completion as custom properties.

When sending from the client, configure the required properties you need to send yourself for the SDK you use, and do not enter the automatically collected required properties in the code. For example, when sending from the client with Hive SDK v4 in a Unity environment, put eventName, the one required property you send, and the custom properties into a JSONObject, then call Analytics.sendAnalyticsLog(logData) to send the event.

JSONObject logData = new JSONObject();
// Required property (send only eventName; the SDK collects the rest automatically)
logData.AddField("eventName", "contents_success");
// Custom properties
logData.AddField("characterLv", 15);
logData.AddField("modeTypeId", 1);
logData.AddField("modeTypeName", "Tutorial_1");
logData.AddField("score", 12);
logData.AddField("playTimeSec", 120);
Analytics.sendAnalyticsLog(logData);

Event Storage

Events collected normally are stored in t_raw_event_log. Events that do not meet the collection criteria, such as a missing required property or an eventTime format error, are quarantined in t_raw_event_log_rescue.

The storage structure of normal and quarantined data and how to check quarantine reasons are covered in detail in "Checking the Event Log Storage Structure and Failed Data: Sending Event Logs, Part 4."

Getting Started with Hive Analytics

To collect actions that occur in the game as consistent event logs, distinguish between required and custom properties, and send the validated values and data types at the moment the actual action is confirmed.

Hive Analytics is an analytics solution built for games that lets you send events in the way that fits your client and server environments and use the collected data for analysis. Connect the event structure of the game actions you want to analyze in Hive Analytics to actual game data today.