Trigger di Google Analytics for Firebase

Beta

Questa funzionalità è coperta dai Termini delle offerte pre-GA dei Termini di servizio Google Cloud. Le funzionalità pre-GA potrebbero avere assistenza limitata e le modifiche alle funzionalità pre-GA potrebbero non essere compatibili con altre versioni pre-GA. Per ulteriori informazioni, consulta le descrizioni della fase di lancio.

In particolare, tieni presente che le funzioni CloudEvent generate dai trigger beta potrebbero cambiare formato nel tempo. Gli attributi Source e Subject, gli attributi di estensione aggiuntivi e il formato dei dati (payload) sono tutti soggetti a modifica.

Google Analytics for Firebase fornisce report sugli eventi che ti aiutano a capire come gli utenti interagiscono con la tua app. Con Cloud Run Functions, puoi accedere agli eventi di conversione che hai registrato da dispositivi Apple e Android e attivare le funzioni in base a questi eventi.

Avviso: Cloud Run Functions supporta solo gli eventi delle piattaforme Apple e Android contrassegnati come eventi di conversione; gli eventi di conversione web non sono disponibili. Puoi specificare quali eventi sono di conversione nella scheda Eventi del riquadro Analytics della console Firebase.

Nota: a differenza della maggior parte degli altri eventi Cloud Run Functions, gli eventi di Google Analytics for Firebase non sono in tempo reale e potrebbero essere ritardati. Per ulteriori informazioni, consulta questo blog post.

Tipi di evento

Google Analytics for Firebase attiva l'evento log. Si tratta di un tipo di evento molto efficace, poiché qualsiasi azione intrapresa da un utente nella tua app può essere registrata e, a sua volta, attivare una funzione.

Tipo di evento	Trigger
providers/google.firebase.analytics/eventTypes/event.log	Attivato quando viene registrato un evento di conversione.

Cloud Run Functions può rispondere alla registrazione di un evento di conversione di Google Analytics for Firebase. Ad esempio, se un utente effettua un acquisto in-app, viene registrato un evento di conversione in_app_purchase che può essere utilizzato da Cloud Run Functions.

Struttura dell'evento

Questo trigger richiama la funzione con un evento simile a quello mostrato di seguito:

{
    "eventDim": [ // Contains a single event
        {
            "date": "20090213",
            "name": "screen_view",
            "params": {
                "firebase_conversion": {
                    "intValue": "1"
                },
                "firebase_event_origin": {
                    "stringValue": "auto"
                },
                "firebase_previous_class": {
                    "stringValue": "MainActivity"
                },
                "firebase_previous_id": {
                    "intValue": "1928209043426257906"
                },
                "firebase_previous_screen": {
                    "stringValue": "id-D-D"
                },
                "firebase_screen": {
                    "stringValue": "id-C-C"
                },
                "firebase_screen_class": {
                    "stringValue": "MainActivity"
                },
                "firebase_screen_id": {
                    "intValue": "1234567890000"
                }
            },
            "previousTimestampMicros": "1234567890000",
            "timestampMicros": "1234567890000"
        }
    ],
    "userDim": {
        // A UserDimensions object
    }
}

Le informazioni sull'utente, come quelle sull'applicazione o sul dispositivo, sono disponibili nella proprietà userDim. Le informazioni sull'evento registrato sono disponibili nell'array eventDim. Gli oggetti contenuti in questo array includono un campo name che contiene il nome dell'evento di conversione (ad esempio in_app_purchase). Qui vengono visualizzati anche i campi personalizzati configurati in Google Analytics for Firebase.

Esempio di codice

Utilizza il seguente snippet per elaborare questa risposta:

Node.js

/**
 * Background Function triggered by a Google Analytics for Firebase log event.
 *
 * @param {!Object} event The Cloud Functions event.
 */
exports.helloAnalytics = event => {
  const {resource} = event;
  console.log(`Function triggered by the following event: ${resource}`);

  const [analyticsEvent] = event.data.eventDim;
  console.log(`Name: ${analyticsEvent.name}`);
  console.log(`Timestamp: ${new Date(analyticsEvent.timestampMicros / 1000)}`);

  const userObj = event.data.userDim;
  console.log(`Device Model: ${userObj.deviceInfo.deviceModel}`);
  console.log(`Location: ${userObj.geoInfo.city}, ${userObj.geoInfo.country}`);
};

Python

from datetime import datetime

def hello_analytics(data, context):
    """Triggered by a Google Analytics for Firebase log event.
    Args:
           data (dict): The event payload.
           context (google.cloud.functions.Context): Metadata for the event.
    """
    trigger_resource = context.resource
    print(f"Function triggered by the following event: {trigger_resource}")

    event = data["eventDim"][0]
    print(f'Name: {event["name"]}')

    event_timestamp = int(event["timestampMicros"][:-6])
    print(f"Timestamp: {datetime.utcfromtimestamp(event_timestamp)}")

    user_obj = data["userDim"]
    print(f'Device Model: {user_obj["deviceInfo"]["deviceModel"]}')

    geo_info = user_obj["geoInfo"]
    print(f'Location: {geo_info["city"]}, {geo_info["country"]}')

Go

// Package p contains a Google Analytics for Firebase Cloud Function.
package p

import (
	"context"
	"fmt"
	"log"

	"cloud.google.com/go/functions/metadata"
)

// AnalyticsEvent is the payload of an Analytics log event.
type AnalyticsEvent struct {
	EventDimensions []EventDimensions `json:"eventDim"`
	UserDimensions  interface{}       `json:"userDim"`
}

// EventDimensions holds Analytics event dimensions.
type EventDimensions struct {
	Name                    string      `json:"name"`
	Date                    string      `json:"date"`
	TimestampMicros         string      `json:"timestampMicros"`
	PreviousTimestampMicros string      `json:"previousTimestampMicros"`
	Params                  interface{} `json:"params"`
}

// HelloAnalytics handles Firebase Mobile Analytics log events.
func HelloAnalytics(ctx context.Context, e AnalyticsEvent) error {
	meta, err := metadata.FromContext(ctx)
	if err != nil {
		return fmt.Errorf("metadata.FromContext: %w", err)
	}
	log.Printf("Function triggered by Google Analytics event: %v", meta.Resource)
	log.Printf("%+v", e)
	return nil
}

C#

using CloudNative.CloudEvents;
using Google.Cloud.Functions.Framework;
using Google.Events.Protobuf.Firebase.Analytics.V1;
using Microsoft.Extensions.Logging;
using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace FirebaseAnalytics;

public class Function : ICloudEventFunction<AnalyticsLogData>
{
    private readonly ILogger _logger;

    public Function(ILogger<Function> logger) =>
        _logger = logger;

    public Task HandleAsync(CloudEvent cloudEvent, AnalyticsLogData data, CancellationToken cancellationToken)
    {
        _logger.LogInformation("Event source: {source}", cloudEvent.Source);
        _logger.LogInformation("Event count: {count}", data.EventDim.Count);

        var firstEvent = data.EventDim.FirstOrDefault();
        if (firstEvent is object)
        {
            _logger.LogInformation("First event name: {name}", firstEvent.Name);
            DateTimeOffset timestamp = DateTimeOffset.FromUnixTimeMilliseconds(firstEvent.TimestampMicros / 1000);
            _logger.LogInformation("First event timestamp: {timestamp:u}", timestamp);
        }

        var userObject = data.UserDim;
        if (userObject is object)
        {
            _logger.LogInformation("Device model: {device}", userObject.DeviceInfo?.DeviceModel);
            _logger.LogInformation("Location: {city}, {country}", userObject.GeoInfo?.City, userObject.GeoInfo.Country);
        }
        // In this example, we don't need to perform any asynchronous operations, so the
        // method doesn't need to be declared async.
        return Task.CompletedTask;
    }
}

Ruby

require "functions_framework"

# Triggered by a Google Analytics for Firebase log event.
FunctionsFramework.cloud_event "hello_analytics" do |event|
  # Event-triggered Ruby functions receive a CloudEvents::Event::V1 object.
  # See https://cloudevents.github.io/sdk-ruby/latest/CloudEvents/Event/V1.html
  # The Analytics event payload can be obtained from the `data` field.
  payload = event.data

  logger.info "Function triggered by the following event: #{event.source}"

  event = payload["eventDim"].first
  logger.info "Name: #{event['name']}"

  event_timestamp = Time.at(event["timestampMicros"].to_i / 1_000_000).utc
  logger.info "Timestamp: #{event_timestamp.strftime '%Y-%m-%dT%H:%M:%SZ'}"

  user_obj = payload["userDim"]
  logger.info "Device Model: #{user_obj['deviceInfo']['deviceModel']}"

  geo_info = user_obj["geoInfo"]
  logger.info "Location: #{geo_info['city']}, #{geo_info['country']}"
end

PHP

use Google\CloudFunctions\CloudEvent;

function firebaseAnalytics(CloudEvent $cloudevent): void
{
    $log = fopen(getenv('LOGGER_OUTPUT') ?: 'php://stderr', 'wb');

    $data = $cloudevent->getData();

    fwrite($log, 'Function triggered by the following event:' . $data['resource'] . PHP_EOL);

    $analyticsEvent = $data['eventDim'][0];
    $unixTime = $analyticsEvent['timestampMicros'] / 1000;

    fwrite($log, 'Name: ' . $analyticsEvent['name'] . PHP_EOL);
    fwrite($log, 'Timestamp: ' . gmdate("Y-m-d\TH:i:s\Z", $unixTime) . PHP_EOL);

    $userObj = $data['userDim'];
    fwrite($log, sprintf(
        'Location: %s, %s' . PHP_EOL,
        $userObj['geoInfo']['city'],
        $userObj['geoInfo']['country']
    ));

    fwrite($log, 'Device Model: %s' . $userObj['deviceInfo']['deviceModel'] . PHP_EOL);
}

Deployment della funzione

Per eseguire il deployment della funzione, specifica il tipo di evento e il progetto in cui hai configurato Firebase Authentication. Nella console c'è un campo per il Tipo di evento che contiene log, l'unica opzione, e il Nome evento di log, ovvero l'evento di conversione che attiverà la funzione.

Nella riga di comando, per specificare questi parametri devono essere utilizzate stringhe specifiche. Il seguente comando Google Cloud CLI esegue il deployment di una funzione che viene attivata quando un utente effettua un acquisto in-app:

gcloud functions deploy FUNCTION_NAME \
  --no-gen2 \
  --entry-point ENTRY_POINT \
  --trigger-event providers/google.firebase.analytics/eventTypes/event.log \
  --trigger-resource projects/YOUR_PROJECT_ID/events/in_app_purchase \
  --runtime RUNTIME

Nota: quando esegui il deployment di una funzione utilizzando Google Cloud CLI, il comando deve includere il nome della funzione contenuta nel codice che vuoi che il comando deploy esegua. Puoi specificare questa funzione utilizzando FUNCTION_NAME o il flag facoltativo --entry-point, a seconda delle esigenze della tua implementazione. Per saperne di più, consulta la guida all'implementazione.

Argomento	Descrizione
FUNCTION_NAME	Il nome registrato della funzione Cloud Run di cui stai eseguendo il deployment. Può essere il nome di una funzione nel tuo codice sorgente o una stringa arbitraria. Se FUNCTION_NAME è una stringa arbitraria, devi includere il flag --entry-point.
--entry-point ENTRY_POINT	Il nome di una funzione o di una classe nel codice sorgente. Facoltativo, a meno che non hai utilizzato FUNCTION_NAME per specificare la funzione nel codice sorgente da eseguire durante il deployment. In questo caso, devi utilizzare --entry-point per fornire il nome della funzione eseguibile.
--trigger-event NAME	Il nome del tipo di evento che la funzione vuole ricevere. Per Google Analytics for Firebase, questo valore è sempre providers/google.firebase.analytics/eventTypes/event.log.
--trigger-resource NAME	Il nome evento Google Analytics completo, incluse le informazioni sul progetto. Deve avere il seguente formato: projects/YOUR_PROJECT_ID/events/CONVERSION_EVENT_NAME
--runtime RUNTIME	Il nome del runtime che stai utilizzando. Per un elenco completo, consulta il riferimento gcloud.