Intégrer Google Analytics

La plate-forme Google Analytics vous permet de mesurer les interactions des utilisateurs avec votre entreprise sur différents appareils et dans divers environnements. Elle fournit toutes les ressources informatiques nécessaires pour collecter, stocker et traiter les données sur ces interactions utilisateur, et générer des rapports les concernant.

La collecte de données analytiques peut s'effectuer côté client et côté serveur. Pour envoyer des données à Google Analytics, vous disposez d'API et de SDK simples à utiliser. En plus de ces outils, nous avons développé du code que vous pouvez exécuter dans vos applications App Engine pour envoyer facilement des données analytiques côté serveur à Google Analytics.

Collecter des données analytiques côté client

Les SDK et les API de collecte permettent de mesurer la manière dont les utilisateurs interagissent avec vos contenus et vos initiatives marketing. Une fois ces outils en place, les données des interactions utilisateur sont accessibles dans Google Analytics ou via les API de création de rapports. Pour en savoir plus sur la collecte de données analytiques côté client, sélectionnez ci-dessous le lien correspondant à votre type de client :

  • Suivi Web (analytics.js) : mesurez les interactions des utilisateurs avec des sites ou des applications Web.
  • Android - mesurez l'interaction de l'utilisateur avec les applications Android.
  • iOS - mesurer l'interaction de l'utilisateur avec les applications iOS.
  • Protocole de mesure : mesurez les interactions des utilisateurs dans n'importe quel environnement avec ce protocole de bas niveau.

Collecter des données analytiques côté serveur App Engine

Bien qu'App Engine fournisse déjà un mécanisme pour consigner les événements dans votre application, vous pouvez suivre des événements spécifiques côté serveur directement dans Google Analytics, qui présente les avantages suivants :

  • Analyse des données de l'historique : App Engine vous permet de configurer le nombre maximal de jours ou la taille de votre fichier journal. Une fois cette limite dépassée, vous n'avez plus accès à ces fichiers journaux. Le suivi des événements dans Google Analytics vous offre une visibilité à beaucoup plus long terme sur les événements passés.
  • Suivi des événements clés : les fichiers journaux peuvent devenir très chargés en détails, car plusieurs composants de votre application y écrivent des données. Le suivi des événements vous permet d'identifier les événements clés et certaines métadonnées que vous souhaitez contrôler.
  • Interface utilisateur puissante : tirez parti de l'interface utilisateur enrichie de Google Analytics pour visualiser et exporter ces événements côté serveur, et créer des rapports les concernant.

Pour ce faire, intégrez simplement l'exemple de code source ci-dessous dans votre application App Engine. Pour en savoir plus sur cette approche, consultez le guide du développeur Google Analytics, et plus particulièrement la section Suivi des événements.

Exemple de code source

Java

package com.google.appengine.analytics.tracking;

import com.google.appengine.api.urlfetch.HTTPHeader;
import com.google.appengine.api.urlfetch.HTTPMethod;
import com.google.appengine.api.urlfetch.HTTPRequest;
import com.google.appengine.api.urlfetch.HTTPResponse;
import com.google.appengine.api.urlfetch.URLFetchService;
import com.google.appengine.api.urlfetch.URLFetchServiceFactory;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.LinkedHashMap;
import java.util.Map;

public class GoogleAnalyticsTracking {

  private static final URL GA_URL_ENDPOINT = getGoogleAnalyticsEndpoint();
  private static final HTTPHeader CONTENT_TYPE_HEADER =
      new HTTPHeader("Content-Type", "application/x-www-form-urlencoded");

  private final String gaTrackingId;  // Tracking ID / Web property / Property ID
  private String gaClientId = "555";  // Anonymous Client ID.
  // Used to override the existing factory with perhaps a mock one for testing.
  private URLFetchService urlFetchService = URLFetchServiceFactory.getURLFetchService();

  private static URL getGoogleAnalyticsEndpoint() {
    try {
      return new URL("http", "www.google-analytics.com", "/collect");
    } catch (MalformedURLException e) {
      throw new RuntimeException(e);
    }
  }

  public GoogleAnalyticsTracking(String gaTrackingId) throws IOException {
    if (gaTrackingId == null) {
      throw new IllegalArgumentException("Can't set gaTrackingId to a null value.");
    }
    this.gaTrackingId = gaTrackingId;
  }

  public GoogleAnalyticsTracking setGoogleAnalyticsClientId(String gaClientId)
      throws IOException {
    if (gaClientId == null) {
      throw new IllegalArgumentException("Can't set gaClientId to a null value.");
    }
    this.gaClientId = gaClientId;
    return this;
  }

  public GoogleAnalyticsTracking setUrlFetchService(URLFetchService urlFetchService)
      throws IOException {
    if (urlFetchService == null) {
      throw new IllegalArgumentException("Can't set urlFetchService to a null value.");
    }
    this.urlFetchService = urlFetchService;
    return this;
  }

  /**
   * Posts an Event Tracking message to Google Analytics.
   *
   * @param category the required event category
   * @param action the required event action
   * @param label the optional event label
   * @param value the optional value
   * @return true if the call succeeded, otherwise false
   * @exception IOException if the URL could not be posted to
   */
  public int trackEventToGoogleAnalytics(
      String category, String action, String label, String value) throws IOException {
    Map<String, String> map = new LinkedHashMap<>();
    map.put("v", "1");             // Version.
    map.put("tid", gaTrackingId);
    map.put("cid", gaClientId);
    map.put("t", "event");         // Event hit type.
    map.put("ec", encode(category, true));
    map.put("ea", encode(action, true));
    map.put("el", encode(label, false));
    map.put("ev", encode(value, false));

    HTTPRequest request = new HTTPRequest(GA_URL_ENDPOINT, HTTPMethod.POST);
    request.addHeader(CONTENT_TYPE_HEADER);
    request.setPayload(getPostData(map));

    HTTPResponse httpResponse = urlFetchService.fetch(request);
    // Return True if the call was successful.
    return httpResponse.getResponseCode();
  }

  private static byte[] getPostData(Map<String, String> map) {
    StringBuilder sb = new StringBuilder();
    for (Map.Entry<String, String> entry : map.entrySet()) {
      sb.append(entry.getKey());
      sb.append('=');
      sb.append(entry.getValue());
      sb.append('&');
    }
    if (sb.length() > 0) {
      sb.setLength(sb.length() - 1); // Remove the trailing &.
    }
    return sb.toString().getBytes(StandardCharsets.UTF_8);
  }

  private static String encode(String value, boolean required)
      throws UnsupportedEncodingException {
    if (value == null) {
      if (required) {
        throw new IllegalArgumentException("Required parameter not set.");
      }
      return "";
    }
    return URLEncoder.encode(value, StandardCharsets.UTF_8.name());
  }
}

Python

def track_event(category, action, label=None, value=0):
    data = {
        'v': '1',  # API Version.
        'tid': GA_TRACKING_ID,  # Tracking ID / Property ID.
        # Anonymous Client Identifier. Ideally, this should be a UUID that
        # is associated with particular user, device, or browser instance.
        'cid': '555',
        't': 'event',  # Event hit type.
        'ec': category,  # Event category.
        'ea': action,  # Event action.
        'el': label,  # Event label.
        'ev': value,  # Event value, must be an integer
    }

    response = requests.post(
        'http://www.google-analytics.com/collect', data=data)

    # If the request fails, this will raise a RequestException. Depending
    # on your application's needs, this may be a non-error and can be caught
    # by the caller.
    response.raise_for_status()

@app.route('/')
def track_example():
    track_event(
        category='Example',
        action='test action')
    return 'Event tracked.'
Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Environnement standard App Engine pour Python 2