Google Analytics für Firebase-Trigger

Google Analytics für Firebase bietet Ereignisberichte, mit denen Sie verstehen, wie Nutzer mit Ihrer App interagieren. Mit Cloud Functions können Sie auf Konvertierungsereignisse zugreifen, die Sie von Apple- und Android-Geräten protokolliert haben, und Funktionen basierend auf diesen Ereignissen auslösen.

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

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

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 FUNCTION_NAME \
  --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 Beschreibung
FUNCTION_NAME Der registrierte Name der Cloud Functions-Funktion, die Sie bereitstellen. Dies kann entweder der Name einer Funktion in Ihrem Quellcode oder ein beliebiger String sein. Wenn FUNCTION_NAME ein beliebiger String ist, müssen Sie das Flag --entry-point einfügen.
--entry-point ENTRY_POINT Der Name einer Funktion oder Klasse in Ihrem Quellcode. Optional, es sei denn, Sie haben FUNCTION_NAME nicht verwendet, um die Funktion in Ihrem Quellcode anzugeben, die während der Bereitstellung ausgeführt werden soll. In diesem Fall müssen Sie mit --entry-point den Namen der ausführbaren Funktion angeben.
--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.