Google Analytics für Firebase-Trigger

Google Analytics für Firebase bietet Ereignisberichte, mit denen Sie verstehen, wie Nutzer mit Ihrer Anwendung interagieren. Mit Cloud Functions können Sie auf protokollierte Konvertierungsereignisse zugreifen und Funktionen basierend auf diesen Ereignissen im selben Cloud-Projekt wie die Funktion auslösen.

Cloud Functions unterstützt nur Conversion-Ereignisse. Auf dem Tab „Ereignisse“ im Analytics-Bereich der Firebase Console können Sie festlegen, welche Ereignisse Conversion-Ereignisse sind.

Ereignistypen

Google Analytics für Firebase löst das log-Ereignis aus. Dies ist ein leistungsfähiger Ereignistyp, da er ermöglicht, jede Aktion, die ein Nutzer in Ihrer Anwendung ausführt, zu protokollieren und eine entsprechende Funktion auszulösen.

Ereignistyp Trigger
providers/google.firebase.analytics/eventTypes/event.log Wird ausgelöst, wenn ein Conversion-Ereignis protokolliert wird

Cloud Functions kann auf das Logging eines Conversion-Ereignisses für Google Analytics für Firebase reagieren. Wenn ein Nutzer beispielsweise einen In-App-Kauf tätigt, wird das Conversion-Ereignis in_app_purchase protokolliert und kann von Cloud Functions genutzt werden.

Ereignisstruktur

Dieser Trigger löst die Funktion mit einem Ereignis wie dem folgenden aus:

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

Nutzerangaben wie Anwendungs- oder Geräteinformationen befinden sich im Attribut userDim. Informationen zum protokollierten Ereignis finden Sie im Array eventDim. Zu den Objekten, die in diesem Array enthalten sind, gehört das Feld name, das den Namen des Conversion-Ereignisses enthält (z. B. in_app_purchase). Außerdem werden hier benutzerdefinierte Felder angezeigt, die in Google Analytics für Firebase eingerichtet wurden.

Codebeispiel

Verarbeiten Sie mit dem folgenden Snippet diese Antwort:

Node.js

/**
 * 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: %v", 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

Funktion bereitstellen

Zum Bereitstellen Ihrer Funktion geben Sie den Ereignistyp und das Projekt an, in dem Sie Firebase Auth konfiguriert haben. In der Console gibt es ein Feld für Ereignistyp, das log als einzige Option enthält, und für Name des Log-Ereignisses – das Conversion-Ereignis, das die Funktion auslöst.

In der Befehlszeile müssen bestimmte Strings zum Angeben dieser Parameter verwendet werden. Mit dem folgenden gcloud-Befehl wird eine Funktion bereitgestellt, die ausgelöst wird, wenn ein Nutzer einen In-App-Kauf tätigt:

gcloud functions deploy YOUR_ANALYTICS_FUNCTION \
  --trigger-event providers/google.firebase.analytics/eventTypes/event.log \
  --trigger-resource projects/YOUR_PROJECT_ID/events/in_app_purchase \
  --runtime RUNTIME
Argument Beschreibung
--trigger-event NAME Der Name des Ereignistyps, den die Funktion erhalten möchte. Bei Google Analytics for Firebase ist dies immer providers/google.firebase.analytics/eventTypes/event.log..
--trigger-resource NAME Der voll qualifizierte Google Analytics-Ereignisname, einschließlich Ihrer Projektinformationen. Er sollte so aufgebaut sein: projects/YOUR_PROJECT_ID/events/CONVERSION_EVENT_NAME.
--runtime RUNTIME Der Name der Laufzeit, die Sie verwenden. Eine vollständige Liste finden Sie in der gcloud-Referenz.