Attivatori di Google Analytics per Firebase

Beta

Questa funzionalità è coperta Termini dell'offerta pre-GA di Google Cloud Termini di servizio. Le funzionalità pre-GA potrebbero avere supporto limitato e 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 CloudEvents che sono generati dagli attivatori beta potrebbero cambiare formato nel tempo. Source e Subject, gli attributi di estensione aggiuntivi e (payload) sono tutti soggetti a modifiche.

Nota: Questi contenuti riguardano solo le funzioni Cloud Run (1ª generazione.), in precedenza Cloud Functions (1ª generazione.).

Cloud Run Functions al momento supportare i trigger di Google Analytics for Firebase.

Google Analytics per Firebase fornisce report sugli eventi che ti aiutano a comprendere in che modo gli utenti interagiscono con la tua app. Con le funzioni Cloud Run, puoi accedere agli eventi di conversione registrati dai dispositivi Apple e Android e attivare le funzioni in base a questi eventi.

Avviso: solo gli eventi della piattaforma Apple e Android contrassegnati come eventi di conversione sono supportati dalle funzioni Cloud Run. Gli eventi di conversione web non sono disponibili. Puoi specificare quali eventi sono eventi di conversione nella scheda Eventi del riquadro Analytics della console Firebase.

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

Tipi di evento

Google Analytics for Firebase attiva l'evento log. Questo è un potente tipo di evento, poiché qualsiasi azione eseguita da un utente nella tua app può essere registrato e a sua volta attivano una funzione.

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

Le funzioni Cloud Run sono in grado di rispondere al logging di un Google Analytics un evento di conversione Firebase. Ad esempio, se un utente effettua un acquisto in-app, viene registrato un in_app_purchase evento di conversione che può essere utilizzato dalle funzioni Cloud Run.

Struttura dell'evento

Questo attivatore invoca 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 utente, come le informazioni sull'applicazione o sul dispositivo, possono essere ritrovate nella proprietà userDim. Informazioni sui disponibile nell'array eventDim. Gli oggetti contenuti in quell'array Includi un campo name contenente il nome dell'evento di conversione (ad esempio in_app_purchase). Campi personalizzati configurati in Google Analytics for Firebase vengono visualizzati anche qui.

Esempio di codice

Utilizza lo snippet seguente 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"]}')

Vai

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

Eseguire il deployment della funzione

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

Nella riga di comando devono essere utilizzate stringhe specifiche per specificare questi parametri. Il seguente comando Google Cloud CLI esegue il deployment di una funzione che si attiva 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, deve includere il nome della funzione contenuta nel codice che che vuoi venga eseguito il comando deploy. Puoi specificare tale funzione utilizzando FUNCTION_NAME o il flag facoltativo --entry-point, a seconda delle esigenze la tua implementazione. Consulta le guida all'implementazione per ulteriori discussioni.

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 del 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 abbia 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 per Firebase, questo valore è sempre providers/google.firebase.analytics/eventTypes/event.log.
--trigger-resource NAME	Il nome completo dell'evento Google Analytics, incluso il progetto informazioni. Deve avere il seguente formato: projects/YOUR_PROJECT_ID/events/CONVERSION_EVENT_NAME
--runtime RUNTIME	Il nome del runtime in uso. Per un elenco completo, vedi Riferimento gcloud.