Android v3 (Legacy) – סקירה כללית

במדריך למפתחים מוסבר איך להטמיע את Google Tag Manager באפליקציה לנייד.

מבוא

Google Tag Manager מאפשר למפתחים לשנות את ערכי התצורה באפליקציות שלהם לנייד באמצעות הממשק של Google Tag Manager, בלי שיצטרכו ליצור מחדש קבצים בינאריים של אפליקציות ולשלוח אותם מחדש לזירות מסחר של אפליקציות.

כך תוכלו לנהל את ערכי ההגדרות והדגלים באפליקציה שאולי תצטרכו לשנות בעתיד, כולל:

  • הגדרות שונות של ממשק המשתמש ומחרוזות תצוגה
  • גדלים, מיקומים או סוגים של מודעות שהוצגו באפליקציה שלכם
  • הגדרות של משחקים

ניתן גם להעריך את ערכי התצורה בזמן ריצה באמצעות כללים, ולהפעיל הגדרות דינמיות כמו:

  • שימוש בגודל המסך לקביעת גודל הבאנר של המודעה
  • שימוש בשפה ובמיקום להגדרת רכיבים בממשק המשתמש

Google TagManager גם מאפשר הטמעה דינמית של פיקסלים ותגים למעקב באפליקציות. מפתחים יכולים לדחוף אירועים חשובים לשכבת נתונים ולהחליט מאוחר יותר אילו תגי מעקב או פיקסלים להפעיל. TagManager תומך כרגע בתגים הבאים:

  • Google Analytics לאפליקציות לנייד
  • תג קריאה לפונקציה מותאמת אישית

לפני שתתחיל

לפני שמשתמשים במדריך לתחילת העבודה, תזדקקו לדברים הבאים:

אם עדיין לא השתמשת ב-Google Tag Manager, מומלץ לעיין במידע נוסף על מאגרי תגים, פקודות מאקרו וכללים (מרכז העזרה) לפני המשך המדריך.

תחילת העבודה

בקטע הזה נסביר למפתחים איך לבצע את תהליך העבודה האופייני של Tag Manager:

  1. הוספת ה-SDK של Google Tag Manager לפרויקט
  2. הגדרת ערכי ברירת מחדל במאגר התגים
  3. פתיחת מאגר התגים
  4. קבלת ערכי תצורה מהמאגר
  5. דחיפת אירועים ל-DataLayer
  6. הצגת תצוגה מקדימה של מאגר התגים ופרסום

1. הוספת Google Tag Manager SDK לפרויקט

לפני שמשתמשים ב-Google Tag Manager SDK, צריך לחלץ את חבילת ה-SDK, להוסיף את הספרייה לנתיב ה-build של הפרויקט ולהוסיף הרשאות לקובץ AndroidManifest.xml.

קודם כול, מוסיפים את הספרייה של Google Tag Manager לתיקייה /libs בפרויקט.

לאחר מכן, מעדכנים את הקובץ AndroidManifest.xml כך שישתמש בהרשאות הבאות:

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.INTERNET" />

2. הוספת קובץ קונטיינר שמוגדר כברירת מחדל לפרויקט

מנהל התגים של Google משתמש במאגר ברירת מחדל בהרצה הראשונה של האפליקציה. המערכת תשתמש במאגר התגים שמוגדר כברירת מחדל עד שהאפליקציה תוכל לאחזר מאגר נתונים חדש ברשת.

כדי להוריד ולהוסיף לאפליקציה שלכם קובץ בינארי של מאגר תגים המוגדר כברירת מחדל, בצעו את השלבים הבאים:

  1. נכנסים לממשק האינטרנט של Google Tag Manager.
  2. בוחרים את הגרסה של מאגר התגים שרוצים להוריד.
  3. לוחצים על הלחצן הורדה כדי לאחזר את קובץ הבינארי של הקונטיינר.
  4. מוסיפים את הקובץ הבינארי לנתיב הבא: <project-root>/assets/tagmanager/

שם הקובץ שמוגדר כברירת מחדל צריך להיות מזהה מאגר התגים (לדוגמה, GTM-1234). לאחר הורדת הקובץ הבינארי, חשוב להסיר את סיומת הגרסה משם הקובץ כדי לוודא שהשם תואם למוסכמות מתן השמות הנכונות.

מומלץ להשתמש בקובץ הבינארי, אבל אם הקונטיינר לא מכיל כללים או תגים, אפשר להשתמש במקום זאת בקובץ JSON פשוט. הקובץ צריך להיות בתיקייה /assets/tagmanager חדשה בפרויקט Android, ועליו להתאים למוסכמת מתן השמות הבאה: <Container_ID>.json. לדוגמה, אם מזהה המאגר הוא GTM-1234, עליכם להוסיף את ערכי ברירת המחדל של מאגר התגים ל-/assets/tagmanager/GTM-1234.json.

3. פתיחת קונטיינר

לפני שמאחזרים ערכים מקונטיינר, האפליקציה צריכה לפתוח את הקונטיינר. פתיחת קונטיינר תטען אותו מהדיסק (אם זמין), או תבקש אותו מהרשת (אם יש צורך).

הדרך הקלה ביותר לפתוח קונטיינר ב-Android היא באמצעות ContainerOpener.openContainer(..., Notifier notifier), כמו בדוגמה הבאה:

import com.google.tagmanager.Container;
import com.google.tagmanager.ContainerOpener;
import com.google.tagmanager.ContainerOpener.OpenType;
import com.google.tagmanager.TagManager;

import android.app.Activity;
import android.os.Bundle;

public class RacingGame {

  // Add your public container ID.
  private static final String CONTAINER_ID = "GTM-YYYY";

  volatile private Container mContainer;

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    TagManager mTagManager = TagManager.getInstance(this);

    // The container is returned to containerFuture when available.
    ContainerOpener.openContainer(
        mTagManager,                            // TagManager instance.
        CONTAINER_ID,                           // Tag Manager Container ID.
        OpenType.PREFER_NON_DEFAULT,            // Prefer not to get the default container, but stale is OK.
        null,                                   // Time to wait for saved container to load (ms). Default is 2000ms.
        new ContainerOpener.Notifier() {        // Called when container loads.
          @Override
          public void containerAvailable(Container container) {
            // Handle assignment in callback to avoid blocking main thread.
            mContainer = container;
          }
        }
    );
    // Rest of your onCreate code.
  }
}

בדוגמה הזו, אפשר להשתמש ב-ContainerOpener.openContainer(..., Notifier notifier) כדי לבקש קונטיינר שמור מהאחסון המקומי. על ידי טיפול בהקצאה של mContainer בקריאה החוזרת (callback) של containerAvailable, אנחנו מוודאים שה-thread הראשי לא חסום. אם מאגר התגים שנשמר ישן מ-12 שעות, השיחה תתזמן גם בקשה לאחזור קונטיינר חדש ברשת באופן אסינכרוני.

ההטמעה לדוגמה הזו מייצגת את הדרך הפשוטה ביותר לפתוח ולאחזר ערכים מתוך מאגר באמצעות מחלקת הנוחות ContainerOpener. לאפשרויות הטמעה מתקדמות יותר, ניתן לעיין בהגדרות מתקדמות.

4. קבלת ערכי תצורה מהמאגר

כשמאגר התגים פתוח, אפשר לאחזר את ערכי התצורה באמצעות השיטות get<type>Value():

// Retrieving a configuration value from a Tag Manager Container.

// Get the configuration value by key.
String title = mContainer.getStringValue("title_string");

בקשות שנשלחות עם מפתח שלא קיים יחזירו ערך ברירת מחדל שמתאים לסוג המבוקש:

// Empty keys will return a default value depending on the type requested.

// Key does not exist. An empty string is returned.
string subtitle = container.getStringValue("Non-existent-key");
subtitle.equals(""); // Evaluates to true.

5. דחיפת ערכים לשכבת הנתונים

DataLayer היא מפה שמאפשרת לקבל מידע על זמן ריצה לגבי האפליקציה, כמו אירועי מגע או צפיות במסך, כזמינות לפקודות מאקרו ותגים של Tag Manager בקונטיינר.

לדוגמה, על ידי דחיפת מידע על צפיות במסך למפה של DataLayer, אפשר להגדיר תגים בממשק האינטרנט של Tag Manager כדי להפעיל פיקסלים של המרות ולמעקב אחרי קריאות למעקב בתגובה לאותן צפיות במסך, בלי לקודד אותם בתוך האפליקציה.

האירועים נדחפים אל DataLayer באמצעות push() ושיטת המסייע DataLayer.mapOf():

//
// MainActivity.java
// Pushing an openScreen event with a screen name into the data layer.
//

import com.google.tagmanager.TagManager;
import com.google.tagmanager.DataLayer;

import android.app.Activity;
import android.os.Bundle;

public MainActivity extends Activity {

  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

  }

  // This screen becomes visible when Activity.onStart() is called.
  public void onStart() {
    super.onStart();

    // The container should have already been opened, otherwise events pushed to
    // the DataLayer will not fire tags in that container.
    DataLayer dataLayer = TagManager.getInstance(this).getDataLayer();
    dataLayer.push(DataLayer.mapOf("event",
                                   "openScreen",      // The event type. This value should be used consistently for similar event types.
                                   "screenName",      // Writes a key "screenName" to the dataLayer map.
                                   "Home Screen")     // Writes a value "Home Screen" for the "screenName" key.
    );
  }
  // Rest of the Activity implementation
}

בממשק האינטרנט אפשר ליצור עכשיו תגים (כמו תגים של Google Analytics) שיופעלו לכל צפייה במסך באמצעות יצירת הכלל הבא: equals "openScreen". כדי להעביר את שם המסך לאחד מהתגים האלה, צריך ליצור מאקרו של שכבת נתונים שמפנה למפתח "screenName" בשכבת הנתונים. אפשר גם ליצור תג (כמו פיקסל המרה של Google Ads) שיפעל רק עבור צפיות מסוימות במסך, על ידי יצירת כלל שבו שווה ל-"openScreen" && שווה "ConfirmationScreen".

6. תצוגה מקדימה ופרסום של כלי קיבול

ערכי המאקרו יתאימו תמיד לגרסה הנוכחית שפורסמה. לפני שתפרסמו את הגרסה האחרונה של מאגר, תוכלו לראות תצוגה מקדימה של טיוטת מאגר התגים.

כדי להציג תצוגה מקדימה של מאגר, יוצרים כתובת URL לתצוגה מקדימה בממשק האינטרנט של Google Tag Manager. לשם כך, בוחרים את הגרסה של מאגר התגים שרוצים להציג בתצוגה מקדימה, ולוחצים על Preview. הישארו עם כתובת ה-URL של התצוגה המקדימה, כי תצטרכו אותה בשלבים הבאים.

כתובות ה-URL של התצוגה המקדימה זמינות בחלון התצוגה המקדימה בממשק האינטרנט של Tag Manager.
איור 1: קבלת כתובת URL של תצוגה מקדימה מממשק האינטרנט של Tag Manager.

בשלב הבא, מוסיפים את הפעילות הבאה לקובץ AndroidManifest.xml של האפליקציה:

<!-- Google Tag Manager Preview Activity -->
<activity
  android:name="com.google.tagmanager.PreviewActivity"
  android:label="@string/app_name"
  android:noHistory="true" >  <!-- Optional, removes the PreviewActivity from activity stack. -->
  <intent-filter>
    <data android:scheme="tagmanager.c.application_package_name" />
    <action android:name="android.intent.action.VIEW" />
    <category android:name="android.intent.category.DEFAULT" />
    <category android:name="android.intent.category.BROWSABLE"/>
  </intent-filter>
</activity>

פותחים את הקישור באמולטור או במכשיר פיזי כדי להציג תצוגה מקדימה של מאגר הטיוטה באפליקציה.

כשהערכים של הגדרת הטיוטה יהיו זמינים לאפליקציה שלכם, עליכם לפרסם את מאגר התגים.

תצורה מתקדמת

ב-Google Tag Manager לנייד יש כמה אפשרויות הגדרה מתקדמות שמאפשרות לבחור ערכים בהתאם לתנאים בזמן הריצה באמצעות כללים, לרענן את המאגר באופן ידני ולקבל אפשרויות נוספות לפתיחת קונטיינרים. בקטעים הבאים מתוארות כמה מהגדרות ההגדרות המתקדמות הנפוצות ביותר.

אפשרויות מתקדמות לפתיחת קונטיינרים

ב-SDK של Google Tag Manager יש כמה שיטות לפתיחת קונטיינרים שיכולים לתת לכם יותר שליטה בתהליך הטעינה:

TagManager.openContainer()

TagManager.openContainer() הוא הרמה הנמוכה ביותר וה-API הגמיש ביותר לפתיחת קונטיינר. הוא מוחזר באופן מיידי עם קונטיינר ברירת מחדל, וגם טוען קונטיינר מהדיסק או מהרשת באופן אסינכרוני אם לא קיים קונטיינר שמור, או אם הקונטיינר שנשמר לא עדכני (לפני יותר מ-12 שעות).

mContainer = tagManager.openContainer(CONTAINER_ID, new Container.Callback() {

  // Called when a refresh is about to begin for the given refresh type.
  @Override
  public void containerRefreshBegin(Container container, RefreshType refreshType) {
    // Notify UI that the Container refresh is beginning.
   }

  // Called when a successful refresh occurred for the given refresh type.
  @Override
  public void containerRefreshSuccess(Container container, RefreshType refreshType]) {
    // Notify UI that Container is ready.
  }

  // Called when a refresh failed for the given refresh type.
  @Override
  public void containerRefreshFailure(Container container,
                                      RefreshType refreshType,
                                      RefreshFailure refreshFailure) {
    // Notify UI that the Container refresh has failed.
  }

במהלך הטעינה, מערכת TagManager.openContainer() מנפיקה כמה קריאות חוזרות (callback) במחזור החיים, כדי שהקוד יוכל לגלות מתי בקשת הטעינה מתחילה, אם היא נכשלת או מצליחה, ואם הקונטיינר נטען בסופו של דבר מהדיסק או מהרשת.

תצטרכו להשתמש בקריאות החוזרות (callback) האלה כדי לדעת מתי נטענו קונטיינרים שמורים או מאגרי רשת, אלא אם האפליקציה שלכם יכולה להשתמש בערכי ברירת המחדל. שימו לב שלא תוכלו לטעון מאגר שמור או מאגר תגים של רשת אם זו הפעם הראשונה שהאפליקציה מופעלת ואין חיבור לרשת.

TagManager.openContainer() מעביר את הערכים הבאים של enum כארגומנטים לקריאה החוזרת (callback):

RefreshType

Valueהתיאור
Container.Callback.SAVED במסגרת הבקשה לרענון, המערכת טוענת מאגר נתונים ששמור באופן מקומי.
Container.Callback.NETWORK במסגרת הבקשה לרענון, המערכת טוענת מאגר תגים ברשת.

RefreshFailure

Valueהתיאור
Container.Callback.NO_SAVED_CONTAINER אין אף מאגר שמור זמין.
Container.Callback.IO_ERROR שגיאה של קלט/פלט (I/O) מנעה רענון של המכל.
Container.Callback.NO_NETWORK אין חיבור רשת זמין.
Container.Callback.NETWORK_ERROR אירעה שגיאת רשת.
Container.Callback.SERVER_ERROR אירעה שגיאה בשרת.
Container.Callback.UNKNOWN_ERROR אירעה שגיאה שלא ניתן לסווג.

שיטות לפתיחת קונטיינרים חדשים ולא ברירת מחדל

השדה ContainerOpener כולל את הטווח TagManager.openContainer() ומספק שתי שיטות לפתיחת קונטיינרים: ContainerOpener.openContainer(..., Notifier notifier) ו-ContainerOpener.openContainer(..., Long timeoutInMillis).

בכל אחת מהשיטות האלה מתבצע ספירה שמבקשת קונטיינר שאינו ברירת המחדל או קונטיינר טרי.

מומלץ להשתמש ב-OpenType.PREFER_NON_DEFAULT לרוב האפליקציות, והוא ינסה להחזיר את הקונטיינר הזמין הראשון שלא מוגדר כברירת מחדל בפרק זמן נתון, מהדיסק או מהרשת, גם אם הוא נוצר לפני יותר מ-12 שעות. אם הוא מחזיר קונטיינר שמור לא פעיל, הוא שולח גם בקשת רשת אסינכרונית עבור מאגר חדש. כשמשתמשים ב-OpenType.PREFER_NON_DEFAULT, מוחזר קונטיינר שמוגדר כברירת מחדל אם אין קונטיינרים אחרים זמינים, או אם חורגים מהזמן הקצוב לתפוגה.

OpenType.PREFER_FRESH מנסה להחזיר קונטיינר חדש מהדיסק או מהרשת במהלך הזמן הקצוב לתפוגה. הפונקציה מחזירה קונטיינר שמור אם החיבור לרשת לא זמין ו/או אם יש חריגה מהזמן הקצוב לתפוגה.

לא מומלץ להשתמש ב-OpenType.PREFER_FRESH במקומות שבהם זמן בקשה ארוך יותר עלול להשפיע באופן משמעותי על חוויית המשתמש, למשל בדגלים של ממשק המשתמש או במחרוזות תצוגה. אפשר גם להשתמש ב-Container.refresh() בכל שלב כדי לאלץ בקשה לקונטיינר של הרשת.

שתי שיטות הנוחות האלה לא חוסמות. ContainerOpener.openContainer(..., Long timeoutInMillis) מחזיר אובייקט ContainerOpener.ContainerFuture, שהשיטה get שלו מחזירה Container מיד אחרי הטעינה (אבל הוא ייחסם עד אז). השיטה ContainerOpener.openContainer(..., Notifier notifier) מבצעת קריאה חוזרת (callback) יחידה, שנקראת כשהמאגר זמין, ואפשר להשתמש בה כדי למנוע חסימה של ה-thread הראשי. בשתי השיטות, פרק הזמן הקצוב לתפוגה שמוגדר כברירת מחדל הוא 2000 אלפיות השנייה.

הערכת פקודות מאקרו בזמן ריצה באמצעות כללים

קונטיינרים יכולים להעריך ערכים בזמן ריצה באמצעות כללים. הכללים יכולים להתבסס על קריטריונים כמו שפת המכשיר, הפלטפורמה או כל ערך מאקרו אחר. לדוגמה, אפשר להשתמש בכללים כדי לבחור מחרוזת תצוגה מותאמת לשוק המקומי בהתאם לשפה של המכשיר בזמן הריצה. אפשר להגדיר זאת באמצעות הכלל הבא:

כלל משמש לבחירת מחרוזות תצוגה המבוססות על שפת המכשיר בזמן ריצה: שפה שווה ל-es. הכלל הזה משתמש במאקרו השפה שהוגדר מראש ובקוד שפה בן שני תווים לפי תקן ISO 639-1.
איור 1: הוספת כלל להפעלת מאקרו של אוסף ערכים רק עבור מכשירים שהוגדרו להשתמש בשפה הספרדית.

לאחר מכן תוכלו ליצור פקודות מאקרו לאיסוף ערכים לכל שפה, ולהוסיף את הכלל הזה לכל מאקרו, ולהוסיף את קוד השפה המתאים. כשהמאגר הזה יפורסם, האפליקציה תוכל להציג מחרוזות תצוגה שהותאמו לשוק המקומי, בהתאם לשפה במכשיר של המשתמש בזמן הריצה.

שימו לב שאם תגדירו כללים לקונטיינר שהגדרתם כברירת מחדל, תצטרכו להשתמש בקובץ קונטיינר בינארי בתור מאגר ברירת המחדל.

מידע נוסף על הגדרת כללים (מרכז העזרה)

קובצי מאגר תגים בינאריים שמוגדרים כברירת מחדל

הקונטיינרים שמוגדרים כברירת מחדל צריכים להשתמש בקובץ קונטיינר בינארי במקום בקובץ JSON בתור הקונטיינר שמוגדר כברירת מחדל. קונטיינרים בינאריים תומכים בקביעת ערכי מאקרו בזמן ריצה באמצעות הכללים של Google Tag Manager, ואילו קובצי JSON לא תומכים בהם.

אפשר להוריד קובצי קונטיינרים בינאריים מממשק האינטרנט של Google Tag Manager, וצריך להוסיף אותם לתיקייה /assets/tagmanager/ של הפרויקט ולפעול לפי התבנית הבאה: /assets/tagmanager/GTM-XXXX, שבה שם הקובץ מייצג את מזהה הקונטיינר.

במקרים שבהם יש קובץ JSON וגם קובץ קונטיינר בינארי, ה-SDK ישתמש בקובץ הקונטיינר הבינארי בתור מאגר ברירת המחדל.

שימוש בפקודות מאקרו של שיחות פונקציה

פקודות מאקרו של שיחות פונקציה הן פקודות מאקרו שמוגדרות לערך המוחזר של פונקציה מסוימת באפליקציה שלכם. אפשר להשתמש בפקודות מאקרו של שיחות פונקציה כדי לשלב ערכי זמן ריצה בכללים של Google Tag Manager, למשל כדי לקבוע בזמן הריצה איזה מחיר להציג למשתמש על סמך השפה והמטבע שהוגדרו במכשיר.

כדי להגדיר מאקרו של קריאה לפונקציה:

  1. מגדירים את המאקרו של הפעלת הפונקציה בממשק האינטרנט של Google Tag Manager. אפשר להגדיר ארגומנטים כצמדי מפתח/ערך.
  2. רושמים FunctionCallMacroHandler באפליקציה באמצעות Container.registerFunctionCallMacroHandler() ושם הפונקציה שהגדרתם בממשק האינטרנט של Google Tag Manager, תוך שינוי השיטה של getValue(): 
    /**
 * Registers a function call macro handler.
 *
 * @param functionName The function name field, as defined in the Google Tag
 *     Manager web interface.
 */
mContainer.registerFunctionCallMacroHandler(functionName, new FunctionCallMacroHandler() {

  /**
   * This code will execute when any custom macro's rule(s) evaluate to true.
   * The code should check the functionName and process accordingly.
   *
   * @param functionName Corresponds to the function name field defined
   *     in the Google Tag Manager web interface.
   * @param parameters An optional map of parameters
   *     as defined in the Google Tag Manager web interface.
   */
  @Override
  public Object getValue(String functionName, Map<String, Object> parameters)) {

    if (functionName.equals("myConfiguredFunctionName")) {
      // Process and return the calculated value of this macro accordingly.
      return macro_value
    }
    return null;
  }
});

שימוש בתגי קריאה של פונקציות

תגי קריאה לפונקציה מאפשרים ביצוע של פונקציות שנרשמו מראש בכל פעם שאירוע מועבר לשכבת הנתונים, וכללי התג מבצעים את ההערכה ל-true.

כדי להגדיר תג קריאה לפונקציה:

  1. יש להגדיר את תג הקריאה לפונקציה בממשק האינטרנט של Google Tag Manager. אפשר להגדיר ארגומנטים כצמדי מפתח/ערך.
  2. רושמים handler של תג קריאה לפונקציה באפליקציה באמצעות Container.registerFunctionCallTagHandler(): 
    /**
 * Register a function call tag handler.
 *
 * @param functionName The function name, which corresponds to the function name field
 *     Google Tag Manager web interface.
 */
mContainer.registerFunctionCallTagHandler(functionName, new FunctionCallTagHandler() {

  /**
   * This method will be called when any custom tag's rule(s) evaluates to true.
   * The code should check the functionName and process accordingly.
   *
   * @param functionName The functionName passed to the functionCallTagHandler.
   * @param parameters An optional map of parameters as defined in the Google
   *     Tag Manager web interface.
   */
  @Override
  public void execute(String functionName, Map<String, Object> parameters) {
    if (functionName.equals("myConfiguredFunctionName")) {
      // Process accordingly.
    }
  }
});

הגדרת תקופת רענון מותאמת אישית

אם גיל המאגר הנוכחי חורג מ-12 שעות, מערכת ה-SDK של Google Tag Manager תנסה לאחזר מאגר תגים חדש. כדי להגדיר תקופת רענון של מאגר מותאם אישית, משתמשים ב-Timer, כמו בדוגמה הבאה:

timer.scheduleTask(new TimerTask() {
  @Override
  public void run() {
    mContainer.refresh();
  }
}, delay, <new_period_in milliseconds>);

ניפוי באגים באמצעות יומן

כברירת מחדל, ה-SDK של Google Tag Manager מדפיס שגיאות ואזהרות ביומנים. הפעלה של רישום מפורט יותר ביומן יכולה להועיל לניפוי באגים, ואפשר גם להטמיע Logger משלכם באמצעות TagManager.setLogger, כמו בדוגמה הבאה:

TagManager tagManager = TagManager.getInstance(this);
tagManager.setLogger(new Logger() {

  final String TAG = "myGtmLogger";

  // Log output with verbosity level of DEBUG.
  @Override
  public void d(String arg0) {
    Log.d(TAG, arg0);
  }

  // Log exceptions when provided.
  @Override
  public void d(String arg0, Throwable arg1) {
    Log.d(TAG, arg0);
    arg1.printStackTrace();
  }

  // Rest of the unimplemented Logger methods.

});

לחלופין, אפשר להגדיר את ה-LogLevel של יומן הרישום הקיים באמצעות TagManager.getLogger().setLogLevel(LogLevel) , כמו בדוגמה הבאה: 

// Change the LogLevel to INFO to enable logging at INFO and higher levels.
TagManager tagManager = TagManager.getInstance(this);
tagManager.getLogger().setLogLevel(LogLevel.INFO);