Settings page for analytics ID

appengine/gaemiddleware/settings.go

 // Copyright 2016 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package gaemiddleware
 
 import (
         "fmt"
 
         "golang.org/x/net/context"
@@ skipping 14 matching lines @@
         // LoggingLevel is logging level to set the default logger to.
         //
         // Log entries below this level will be completely ignored. They won't even
         // reach GAE logging service. Default is logging.Debug (all logs hit logging
         // service).
         LoggingLevel logging.Level `json:"logging_level"`
 
         // DisableDSCache is true to disable dscache (the memcache layer on top of
         // the datastore).
         DisableDSCache settings.YesOrNo `json:"disable_dscache"`
+
+        // AnalyticsID is a Google Analytics ID an admin can set to enable Analytics.
+        // The app must support analytics for this to work.
+        AnalyticsID string `json:"analytics_id"`

[Vadim Sh., 2016/08/26 21:55:05]

I'm confused, why do you have it in two places? Let's keep only
server/analytics, since it's not related to GAE at all.

[hinoka, 2016/08/26 23:11:35]

This was a mistake (well, vestige), deleted.

 }
 
 // fetchCachedSettings fetches gaeSettings from the settings store or panics.
 //
 // Uses in-process global cache to avoid hitting datastore often. The cache
 // expiration time is 1 min (see gaesettings.expirationTime), meaning
 // the instance will refetch settings once a minute (blocking only one unlucky
 // request to do so).
 //
 // Panics only if there's no cached value (i.e. it is the first call to this
 // function in this process ever) and datastore operation fails. It is a good
 // idea to implement /_ah/warmup to warm this up.
 func fetchCachedSettings(c context.Context) gaeSettings {
         s := gaeSettings{}
         switch err := settings.Get(c, settingsKey, &s); {
         case err == nil:
                 return s
         case err == settings.ErrNoSettings:
                 // Defaults.
                 return gaeSettings{
                         LoggingLevel:   logging.Debug,
                         DisableDSCache: false,
+                        AnalyticsID:    "",
                 }
         default:
                 panic(fmt.Errorf("could not fetch GAE settings - %s", err))
         }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // UI for GAE settings.
 
 type settingsUIPage struct {
@@ skipping 26 matching lines @@
                 settings.YesOrNoField(settings.UIField{
                         ID:    "DisableDSCache",
                         Title: "Disable datastore cache",
                         Help: `Usually caching is a good thing and it can be left enabled. You may
 want to disable it if memcache is having issues that prevent entity writes to
 succeed. See <a href="https://godoc.org/github.com/luci/gae/filter/dscache">
 dscache documentation</a> for more information. Toggling this on and off has
 consequences: <b>memcache is completely flushed</b>. Do not toy with this
 setting.`,
                 }),
+                {
+                        ID:    "AnalyticsID",
+                        Title: "Google Analytics Trakcing ID",
+                        Type:  settings.UIFieldText,
+                        Help: `Tracking ID used for Google Analytics.  Filling this in does not
+by itself add analytics to the app, it must be embedded in the HTML templates
+by calling <TODO: WHAT?>`,
+                },
         }, nil
 }
 
 func (settingsUIPage) ReadSettings(c context.Context) (map[string]string, error) {
         s := gaeSettings{}
         err := settings.GetUncached(c, settingsKey, &s)
         if err != nil && err != settings.ErrNoSettings {
                 return nil, err
         }
         return map[string]string{
                 "LoggingLevel":   s.LoggingLevel.String(),
                 "DisableDSCache": s.DisableDSCache.String(),
+                "AnalyticsID":    s.AnalyticsID,
         }, nil
 }
 
 func (settingsUIPage) WriteSettings(c context.Context, values map[string]string, who, why string) error {
         modified := gaeSettings{}
         if err := modified.LoggingLevel.Set(values["LoggingLevel"]); err != nil {
                 return err
         }
         if err := modified.DisableDSCache.Set(values["DisableDSCache"]); err != nil {
                 return err
         }
+        modified.AnalyticsID = values["AnalyticsID"]
 
         // When switching dscache back on, wipe memcache.
         existing := gaeSettings{}
         err := settings.GetUncached(c, settingsKey, &existing)
         if err != nil && err != settings.ErrNoSettings {
                 return err
         }
         if existing.DisableDSCache && !modified.DisableDSCache {
                 logging.Warningf(c, "DSCache was reenabled, wiping memcache")
                 if err := memcache.Get(c).Flush(); err != nil {
                         return err
                 }
         }
 
         return settings.SetIfChanged(c, settingsKey, &modified, who, why)
 }
 
 func init() {
         settings.RegisterUIPage(settingsKey, settingsUIPage{})
 }