Send Events #

You can send events through the SDK or from Pragma services.

Send from a Pragma service #

Game and social platform services and plugin implementations record events through TelemetryClientNodeService. It routes to the co-located TelemetryService or to a dedicated Telemetry backend transparently, so the caller doesn’t choose.

import java.util.UUID
import pragma.telemetry.client.TelemetryClientEvent
import pragma.telemetry.client.TelemetryClientNodeService

//...

private lateinit var telemetryClient: TelemetryClientNodeService

override suspend fun run() {
    telemetryClient = nodeServicesContainer[TelemetryClientNodeService::class]
}

fun recordMenuInteraction(playerId: UUID, data: MenuInteractionPayload) {
    // use a playerId as sourceId to identify events by the same player,
    // or the service class name for events not tied to one player
    telemetryClient.recordEvent(
        TelemetryClientEvent(
            sourceId = playerId.toString(),
            name = "player-open-menu",
            data = data,
        )
    )
}

recordEvent takes a single TelemetryClientEvent; recordEvents takes a List<TelemetryClientEvent>. Each event carries a sourceId, a name, and a data payload that must be a Kotlin data class. Both return a Job: the send happens in the background, and failures are logged rather than surfaced to the caller. For a synchronous call that returns a PragmaResult the caller can react to, use sendEvent/sendEvents instead.

Send from a client using the Unreal SDK #

// defined event data with any structure wanted
USTRUCT()
struct FEventData {
  GENERATED_BODY()

  UPROPERTY()
  FString SelectedHero;

  UPROPERTY()
  FString SelectedRole;
};

void AUnicornPlayerController::CallTelemetry(const FEventData &Data) {
  FString JsonString;
  FJsonObjectConverter::UStructToJsonObjectString<FEventData>(Data, JsonString);

  const FPragma_Telemetry_TelemetryEvent Event = {
    "hero-selected-event",
    JsonString
  };
  const FPragma_Telemetry_PlayerEventV1Request &Request = {Event};

  // use PlayerEventsV1 to send batch
  Player->Api<UPragmaTelemetryServiceRaw>().PlayerEventV1(
      Request, UPragmaTelemetryServiceRaw::FPlayerEventV1Delegate::CreateLambda(
                   [](TPragmaResult<
                          FPragma_Telemetry_PlayerEventV1Response> /* Result */,
                      const FPragmaMessageMetadata & /* Metadata */) {}));
}

Send from a game server using the Unreal SDK #

// a FServerEventData is UStruct defined by you with relevant event data
void AUnicornGameMode::ExampleTelemetryCall(const FServerEventData &Data) {
  FString JsonString;
  FJsonObjectConverter::UStructToJsonObjectString<FServerEventData>(
    Data,
    JsonString
    );

  const FPragma_Telemetry_TelemetryEvent Event = {
    "server-event",
    JsonString
  };
  const FPragma_Telemetry_SourcedEvent SourcedEvent = {
    "<game-server-id>",
    Event
  };
  const auto Events = new TArray<FPragma_Telemetry_SourcedEvent>();
  Events->Add(SourcedEvent);
  const FPragma_Telemetry_EventsPartnerV1Request &Request = {*Events};

  // Use EventPartnerV1 for single event
  const Pragma::FServerPtr PartnerSdk;
  PartnerSdk->Api<UPragmaTelemetryPartnerServiceRaw>().EventsPartnerV1(
      Request,
      UPragmaTelemetryPartnerServiceRaw::FEventsPartnerV1Delegate::CreateLambda(
          [](TPragmaResult<
                 FPragma_Telemetry_EventsPartnerV1Response> /* Result */,
             const FPragmaMessageMetadata & /* Metadata */) {}));
}

Plugins
Schema of Events