CloudWatchLink
Amazon CloudWatch for Blueprints and C++

Overview

CloudWatchLink connects Unreal Engine 4.27 and 5.8 to Amazon CloudWatch and CloudWatch Logs. Your game clients and dedicated servers send their log output and performance metrics to your AWS account, where you search them, chart them on dashboards and get alarms when something goes wrong. Requests run on background worker threads with automatic retries; every result arrives on the game thread.

• CloudWatchLink Logger (game-instance subsystem): UE_LOG forwarding with level, category and wildcard filters, structured JSON lines with context fields, background batching, flush on exit.
• CloudWatchLink Metrics (actor component): FPS, frame time, game / render / RHI thread time, GPU time, memory, player count, ping, plus counters, gauges and timings.
• CloudWatch Logs: groups, streams, retention, Put Log Events with automatic batching, Get Log Events, Filter Log Events.
• Logs Insights: Run Query And Wait returns a result table in one node; ten presets for game logs; CSV export.
• CloudWatch metrics: Put Metric(s), Get Metric Data (metric math), Get Metric Statistics (percentiles), List Metrics, Embedded Metric Format.
• Alarms and dashboards for live-ops tools, with widget and body builders.

Requirements

Installation

1. Install CloudWatchLink from Fab into your engine, or copy the CloudWatchLink folder into your project's Plugins folder.
2. Enable CloudWatchLink in Edit > Plugins and restart the editor.
3. Open Project Settings > Plugins > CloudWatchLink and set Region, Identity Pool Id, Log Group Name and Default Namespace.
4. C++ only: add PublicDependencyModuleNames.Add("CloudWatchLink"); to your Build.cs.

Setting up AWS

1. In Amazon Cognito create an identity pool with guest access (game clients send logs before players sign in).
2. Create the log group, for example /mygame/client, with a retention period (or let CloudWatchLink create it — that needs logs:CreateLogGroup and logs:PutRetentionPolicy).
3. Give the player role of the pool only what the game client needs — writing to its own log group and putting metrics in its own namespace:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["logs:CreateLogStream", "logs:PutLogEvents"],
      "Resource": "arn:aws:logs:us-east-1:123456789012:log-group:/mygame/client:*"
    },
    {
      "Effect": "Allow",
      "Action": "cloudwatch:PutMetricData",
      "Resource": "*",
      "Condition": { "StringEquals": { "cloudwatch:namespace": "Game/MyGame" } }
    }
  ]
}

If the role may not create the group, create it in the console first: the logger's first CreateLogGroup then fails with AccessDeniedException, but the group exists and forwarding continues (the stream is created with logs:CreateLogStream). To let the plugin create the group too, add logs:CreateLogGroup and logs:PutRetentionPolicy on arn:aws:logs:us-east-1:123456789012:log-group:/mygame/client.

Quick start

Forward the Output Log

1. Enable Auto Start Forwarding in the settings — or, in your Game Instance's Init event, get CloudWatchLink Logger and call Start Forwarding.
2. After login call Set Context Field with Name player and the player id.
3. Play. Lines appear in CloudWatch Logs under /mygame/client, stream MyGame/Windows/<session id>, as JSON such as {"timestamp":"2026-10-29T12:00:00.123Z","level":"Warning","category":"LogNet","message":"...","session":"...","platform":"Windows","build":"...","project":"MyGame","player":"p-42"}.

Send game metrics

1. Add a CloudWatchLink Metrics component to your GameState (or player controller). It starts at BeginPlay.
2. Call Increment Counter (Kills), Set Gauge (EnemiesAlive) or Record Timing (LoadTime) from gameplay.
3. Every 60 seconds the component sends FPS, FrameTime, GameThreadTime, RenderThreadTime, RHIThreadTime, GPUTime, MemoryUsed, MemoryAvailable, PlayerCount, Ping and your metrics with the dimensions Map and Platform.

Read the latest errors back (tool)

1. Run Query And Wait with Query = Make Logs Insights Query (Recent Errors), Log Groups empty (= the settings' group).
2. On Success, show Results > Rows (each row a map: @timestamp, level, category, message, session) or save Query Results To CSV.

Logger (UE_LOG forwarding)

The forwarder is an output device registered with GLog plus one background sender thread, shared by the whole process.

• Thread-safe: UE_LOG may be called from any thread. The capture step only checks level and category, copies the line into a bounded in-memory queue and returns; formatting, wildcard filtering and the network requests happen on the sender thread.
• Never blocks the game thread: no request is ever made on the logging thread. Stop Forwarding and the end of Play In Editor return immediately; the rest is sent in the background.
• No recursion: the category LogCloudWatchLink (the plugin's own messages and AWS SDK warnings) is never forwarded, nor is anything logged on the sender thread itself.
• Batching: lines are sent every Flush Interval Seconds (5) or as soon as Max Batch Lines (1000) are waiting, sorted by time and split by the PutLogEvents limits (10,000 events, 1 MB, 24 hours per request, 256 KB per event).
• Bounded memory: at most Max Buffered Lines (20,000) are kept while CloudWatch is unreachable; newer lines are counted in Get Dropped Count. Failed sends with retryable errors keep their lines for the next attempt.
• Shutdown: on engine exit the forwarder detaches from GLog, sends what is left within Shutdown Flush Seconds (3), aborts the request in flight if it takes longer and stops its thread before the module unloads.
• Destination: the log group from the settings (or Start Forwarding), stream <Log Stream Prefix>/<platform>/<session>; both are created when missing.

Metrics component

Frame metrics are sampled every frame, memory / players / ping every Sample Interval (5 s); everything is aggregated per Flush Interval (60 s) into statistic sets (sample count, sum, minimum, maximum), so one minute of frame times costs one data point. Counters are summed, gauges and timings become statistic sets. Thread and GPU times are measured only where frames are drawn (they are left out on dedicated servers); ping is sent on clients only. Retryable failures (throttling, network) keep the data for the next flush, up to Max Pending Datums.

Node reference

All 90 nodes, grouped by Blueprint category. Latent nodes run in the background, fire exactly one final pin on the game thread and can be stopped with Cancel. Nodes marked (admin) need admin IAM permissions. Unset times on read nodes mean "the last hour" unless stated otherwise.

Config and identity

Logger (CloudWatchLink Logger subsystem)

Metrics component (CloudWatchLink Metrics)

Events: On Flushed (Datum Count) and On Failed (Error).

Logs

Logs Insights

Metrics

Alarms

Dashboards

JSON

Logs Insights presets

The presets need Structured JSON on (the default): Logs Insights discovers the JSON fields of each line automatically.

C++ API

#include "CloudWatchLinkLibrary.h"
#include "CloudWatchLinkLogger.h"

// Metrics with a game-thread callback.
TArray<FCloudWatchLinkMetricDatum> Data;
Data.Add(UCloudWatchLinkLibrary::MakeMetricDatum(TEXT("MatchLength"), 312.f, ECloudWatchLinkUnit::Seconds,
	TMap<FString, FString>(), false, FDateTime(0)));
UCloudWatchLinkLibrary::PutMetricsNative(FString(), Data,
	FCloudWatchLinkNativeDelegate::CreateLambda([](const FCloudWatchLinkError& Error) { /* ... */ }));

// The logger is a game-instance subsystem.
if (UCloudWatchLinkLogger* Logger = GetGameInstance()->GetSubsystem<UCloudWatchLinkLogger>())
{
	FString Problem;
	Logger->StartForwarding(FString(), FString(), Problem);
	Logger->SetContextField(TEXT("match"), MatchId);
}

All latent node classes (UCloudWatchLinkSimpleAction, UCloudWatchLinkQueryAction and the others) can be created from C++ through their static factory functions; bind the delegates, then call Activate().

Types

Settings

Project Settings > Plugins > CloudWatchLink (saved to DefaultGame.ini). Connection changes apply to the next request; forwarding filters apply at the next Start Forwarding (or use the Set ... nodes at runtime).

Costs

CloudWatch is billed per GB of ingested and stored log data, per custom metric (each unique combination of name and dimensions), per API request (reads, PutMetricData), per alarm, per dashboard and per GB scanned by Logs Insights. For large player bases keep Minimum Level at Warning in Shipping builds, use few dimensions (Map and Platform are low-cardinality; never use player ids as dimensions), keep the metrics component's Flush Interval at 60 s, and set a retention period on every log group. Log Metrics EMF is a cheap way to get metrics from servers that already forward logs.

Troubleshooting

Credits

© 2026 Alpha XP — alphaxp.net · Support: support@alphaxp.net. Includes the AWS SDK for C++ and the AWS Common Runtime (Apache License 2.0). Built for Unreal Engine 4.27 and 5.8.