Cloud Functions (1st gen) has been renamed to Cloud Run functions (1st gen). Switch to the Cloud Run functions documentation.

Déclencheurs Google Analytics pour Firebase

Google Analytics pour Firebase fournit des rapports sur les événements qui vous aident à comprendre comment les utilisateurs interagissent avec votre application. Avec Cloud Run Functions, vous pouvez accéder aux événements de conversion que vous avez enregistrés à partir d'appareils Apple et Android, et déclencher des fonctions basées sur ces événements.

Types d'événement

Google Analytics pour Firebase déclenche l'événement log. Il s'agit d'un type d'événement puissant, car toute action effectuée par un utilisateur dans votre application peut être consignée, puis être utilisée pour déclencher une fonction.

Type d'événement	Déclencheur
`providers/google.firebase.analytics/eventTypes/event.log`	Déclenché lorsqu'un événement de conversion est consigné.

Cloud Run Functions peut répondre à la journalisation d'un événement de conversion Google Analytics pour Firebase. Par exemple, si un utilisateur effectue un achat via une application, un événement de conversion in_app_purchase est consigné et peut être utilisé par Cloud Run Functions.

Structure de l'événement

Ce déclencheur appelle votre fonction avec un événement semblable à celui présenté ci-dessous :

{
    "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
    }
}

La propriété userDim contient des informations sur l'utilisateur, telles que des informations sur l'application ou l'appareil utilisé. Vous trouverez des informations sur l'événement consigné dans le tableau eventDim. Les objets contenus dans ce tableau incluent un champ name indiquant le nom de l'événement de conversion, tel que in_app_purchase. Les champs personnalisés configurés dans Google Analytics pour Firebase s'affichent également ici.

Exemple de code

Utilisez l'extrait suivant pour traiter cette réponse :

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

Déployer votre fonction

Pour déployer votre fonction, spécifiez le type d'événement et le projet dans lequel Firebase Auth est configuré. La console contient un champ Type d'événement avec log (la seule option) et un champ Nom de l'événement de journal, qui correspond à l'événement de conversion qui déclenche la fonction.

Sur la ligne de commande, des chaînes spécifiques doivent être utilisées pour spécifier ces paramètres. La commande de Google Cloud CLI suivante déploie une fonction qui se déclenche lorsqu'un utilisateur effectue un achat via une application :

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

Argument	Description
`FUNCTION_NAME`	Nom enregistré de la fonction Cloud Run que vous déployez. Il peut s'agir du nom d'une fonction dans votre code source ou d'une chaîne arbitraire. Si `FUNCTION_NAME` est une chaîne arbitraire, vous devez alors inclure l'option `--entry-point`.
`--entry-point ENTRY_POINT`	Nom d'une fonction ou d'une classe dans votre code source. Ce paramètre est facultatif, sauf si vous n'avez pas utilisé `FUNCTION_NAME` pour spécifier quelle fonction de votre code source exécuter lors du déploiement. Dans ce cas, vous devez utiliser `--entry-point` pour fournir le nom de la fonction exécutable.
`--trigger-event NAME`	Nom du type d'événement que la fonction souhaite recevoir. Pour Google Analytics pour Firebase, il s'agit toujours de `providers/google.firebase.analytics/eventTypes/event.log.`
`--trigger-resource NAME`	Nom complet de l'événement Google Analytics, y compris les informations relatives à votre projet. Celui-ci doit se présenter comme suit : `projects/YOUR_PROJECT_ID/events/CONVERSION_EVENT_NAME`
`--runtime RUNTIME`	Nom de l'environnement d'exécution que vous utilisez. Pour obtenir une liste complète, consultez la documentation de référence sur `gcloud`.