suspend fun telemetryEventExample() {
        // create events with wanted data
        val eventData = mapOf(
            "menuClicked" to "shopkeeper",
            "durationMenuOpenSeconds" to "43",
            "interactionsInMenu" to "7",
            "transactions" to 2
        )

        // put data on request 
        val sourcedEvent = SourcedEvent
            .newBuilder()
             // use the service class name 
             // or player id if you want identify events by the same player
            .setSourceId(playerId)
            .setEvent(
                TelemetryEvent.newBuilder()
                    .setName("player-open-menu",)
                    .setJson(PragmaSerializationUtils.toJsonString(eventData))
                    .build()
            )
            .build()
        val telemetryRequest = EventsServiceV1Request.newBuilder()
            .addAllEvents(listOf(sourcedEvent))
            .build()
        
        // send request to Telemetry Service
        val result = requestRpcV2(telemetryRequest, EventsServiceV1Response::parseFrom)
        result.onFailure { 
            // the service to service call failed
            // handle error as wanted: log, throw another error, etc ...
        }
        result.onSuccess {
            // the call was successful and event was stored
        }
    }

// 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 */) {}));
}

// 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 */) {}));
}