Firebase Analytics

Triggers a function when a Firebase Analytics event is received.

Documentation pages that include this code sample

To view the code sample used in context, see the following documentation:

Code sample


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;


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

import (


// 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


 * 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] =;
  console.log(`Name: ${}`);
  console.log(`Timestamp: ${new Date(analyticsEvent.timestampMicros / 1000)}`);

  const userObj =;
  console.log(`Device Model: ${userObj.deviceInfo.deviceModel}`);
  console.log(`Location: ${}, ${}`);


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,

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


from datetime import datetime
def hello_analytics(data, context):
    """ Triggered by a Google Analytics for Firebase log event.
            data (dict): The event payload.
            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"]}')


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
  # The Analytics event payload can be obtained from the `data` field.
  payload = "Function triggered by the following event: #{event.source}"

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

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

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

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

What's next

To search and filter code samples for other Google Cloud products, see the Google Cloud sample browser