Bug 1313095 - Add telemetry to measure if cache loads are faster than network loads r=michal

MozReview-Commit-ID: C6kMSPw8gxv * * * [mq]: bug1313095-telemetry-reval.patch MozReview-Commit-ID: 8jwMgq0cx3Z
2016-11-10 16:14:34 +01:00 · 2016-11-10 16:14:34 +01:00 · 3c75088cde
--- a/netwerk/cache2/CacheEntry.cpp
+++ b/netwerk/cache2/CacheEntry.cpp
@ -1547,6 +1547,15 @@ NS_IMETHODIMP CacheEntry::Close()
  return NS_OK;
 }

+NS_IMETHODIMP CacheEntry::GetDiskStorageSizeInKB(uint32_t *aDiskStorageSize)
+{
+  if (NS_FAILED(mFileStatus)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return mFile->GetDiskStorageSizeInKB(aDiskStorageSize);
+}
+
 // nsIRunnable

 NS_IMETHODIMP CacheEntry::Run()
--- a/netwerk/cache2/CacheFile.cpp
+++ b/netwerk/cache2/CacheFile.cpp
@ -1230,6 +1230,17 @@ CacheFile::GetFetchCount(uint32_t *_retval)
  return mMetadata->GetFetchCount(_retval);
 }

+nsresult
+CacheFile::GetDiskStorageSizeInKB(uint32_t *aDiskStorageSize)
+{
+  if (!mHandle) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  *aDiskStorageSize = mHandle->FileSizeInK();
+  return NS_OK;
+}
+
 nsresult
 CacheFile::OnFetched()
 {
--- a/netwerk/cache2/CacheFile.h
+++ b/netwerk/cache2/CacheFile.h
@ -105,6 +105,7 @@ public:
  nsresult GetLastModified(uint32_t *_retval);
  nsresult GetLastFetched(uint32_t *_retval);
  nsresult GetFetchCount(uint32_t *_retval);
+  nsresult GetDiskStorageSizeInKB(uint32_t *aDiskStorageSize);
  // Called by upper layers to indicated the entry has been fetched,
  // i.e. delivered to the consumer.
  nsresult OnFetched();
--- a/netwerk/cache2/CacheIOThread.cpp
+++ b/netwerk/cache2/CacheIOThread.cpp
@ -341,6 +341,17 @@ bool CacheIOThread::IsCurrentThread()
  return mThread == PR_GetCurrentThread();
 }

+uint32_t CacheIOThread::QueueSize(bool highPriority)
+{
+  MonitorAutoLock lock(mMonitor);
+  if (highPriority) {
+    return mQueueLength[OPEN_PRIORITY] + mQueueLength[READ_PRIORITY];
+  }
+
+  return mQueueLength[OPEN_PRIORITY] + mQueueLength[READ_PRIORITY] +
+         mQueueLength[MANAGEMENT] + mQueueLength[OPEN] + mQueueLength[READ];
+}
+
 bool CacheIOThread::YieldInternal()
 {
  if (!IsCurrentThread()) {
--- a/netwerk/cache2/CacheIOThread.h
+++ b/netwerk/cache2/CacheIOThread.h
@ -67,6 +67,8 @@ public:
  nsresult DispatchAfterPendingOpens(nsIRunnable* aRunnable);
  bool IsCurrentThread();

+  uint32_t QueueSize(bool highPriority);
+
  /**
   * Callable only on this thread, checks if there is an event waiting in
   * the event queue with a higher execution priority.  If so, the result
--- a/netwerk/cache2/CacheStorageService.cpp
+++ b/netwerk/cache2/CacheStorageService.cpp
@ -2010,6 +2010,14 @@ CacheStorageService::GetCacheEntryInfo(CacheEntry* aEntry,
                         aEntry->IsPinned());
 }

+// static
+uint32_t CacheStorageService::CacheQueueSize(bool highPriority)
+{
+  RefPtr<CacheIOThread> thread = CacheFileIOManager::IOThread();
+  MOZ_ASSERT(thread);
+  return thread->QueueSize(highPriority);
+}
+
 // Telementry collection

 namespace {
--- a/netwerk/cache2/CacheStorageService.h
+++ b/netwerk/cache2/CacheStorageService.h
@ -111,6 +111,8 @@ public:
  // Invokes OnEntryInfo for the given aEntry, synchronously.
  static void GetCacheEntryInfo(CacheEntry* aEntry, EntryInfoCallback *aVisitor);

+  static uint32_t CacheQueueSize(bool highPriority);
+
  // Memory reporting
  size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
  size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
--- a/netwerk/cache2/OldWrappers.h
+++ b/netwerk/cache2/OldWrappers.h
@ -105,6 +105,11 @@ public:
                       mOldDesc->SetMetaDataElement(key, value);
  }

+  NS_IMETHOD GetDiskStorageSizeInKB(uint32_t *aDiskStorageSize) override
+  {
+    return NS_ERROR_NOT_IMPLEMENTED;
+  }
+
  // nsICacheEntryInfo
  NS_IMETHOD GetKey(nsACString & aKey) override
  {
--- a/netwerk/cache2/nsICacheEntry.idl
+++ b/netwerk/cache2/nsICacheEntry.idl
@ -173,6 +173,11 @@ interface nsICacheEntry : nsISupports
   */
  void setValid();

+  /**
+   * Returns the size in kilobytes used to store the cache entry on disk.
+   */
+   readonly attribute uint32_t diskStorageSizeInKB;
+
  /**
   * Doom this entry and open a new, empty, entry for write.  Consumer has
   * to exchange the entry this method is called on for the newly created.
--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@ -101,6 +101,7 @@
 #include "CacheControlParser.h"
 #include "nsMixedContentBlocker.h"
 #include "HSTSPrimerListener.h"
+#include "CacheStorageService.h"

 namespace mozilla { namespace net {

@ -242,6 +243,8 @@ nsHttpChannel::nsHttpChannel()
    , mOfflineCacheLastModifiedTime(0)
    , mInterceptCache(DO_NOT_INTERCEPT)
    , mInterceptionID(gNumIntercepted++)
+    , mCacheOpenWithPriority(false)
+    , mCacheQueueSizeWhenOpen(0)
    , mCachedContentIsValid(false)
    , mCachedContentIsPartial(false)
    , mCacheOnlyMetadata(false)
@ -3566,6 +3569,10 @@ nsHttpChannel::OpenCacheEntry(bool isHttps)
            MOZ_ASSERT(NS_SUCCEEDED(cacheStorage->Exists(openURI, extension, &exists)) && exists,
                       "The entry must exist in the cache after we create it here");
        }
+
+        mCacheOpenWithPriority = cacheEntryOpenFlags & nsICacheStorage::OPEN_PRIORITY;
+        mCacheQueueSizeWhenOpen = CacheStorageService::CacheQueueSize(mCacheOpenWithPriority);
+
        rv = cacheStorage->AsyncOpenURI(openURI, extension, cacheEntryOpenFlags, this);
        NS_ENSURE_SUCCESS(rv, rv);
    }
@ -6369,6 +6376,7 @@ nsHttpChannel::OnStartRequest(nsIRequest *request, nsISupports *ctxt)
               "If we have both pumps, the cache content must be partial");

    mAfterOnStartRequestBegun = true;
+    mOnStartRequestTimestamp = TimeStamp::Now();

    if (!mSecurityInfo && !mCachePump && mTransaction) {
        // grab the security info from the connection object; the transaction
@ -6526,6 +6534,8 @@ nsHttpChannel::OnStopRequest(nsIRequest *request, nsISupports *ctxt, nsresult st

    if (mTimingEnabled && request == mCachePump) {
        mCacheReadEnd = TimeStamp::Now();
+
+        ReportNetVSCacheTelemetry();
    }

    // allow content to be cached if it was loaded successfully (bug #482935)
@ -6606,6 +6616,20 @@ nsHttpChannel::OnStopRequest(nsIRequest *request, nsISupports *ctxt, nsresult st

        mTransferSize = mTransaction->GetTransferSize();

+        // If we are using the transaction to serve content, we also save the
+        // time since async open in the cache entry so we can compare telemetry
+        // between cache and net response.
+        if (request == mTransactionPump && mCacheEntry &&
+            !mAsyncOpenTime.IsNull() && !mOnStartRequestTimestamp.IsNull()) {
+            nsAutoCString onStartTime;
+            onStartTime.AppendInt( (uint64_t) (mOnStartRequestTimestamp - mAsyncOpenTime).ToMilliseconds());
+            mCacheEntry->SetMetaDataElement("net-response-time-onstart", onStartTime.get());
+
+            nsAutoCString responseTime;
+            responseTime.AppendInt( (uint64_t) (TimeStamp::Now() - mAsyncOpenTime).ToMilliseconds());
+            mCacheEntry->SetMetaDataElement("net-response-time-onstop", responseTime.get());
+        }
+
        // at this point, we're done with the transaction
        mTransactionTimings = mTransaction->Timings();
        mTransaction = nullptr;
@ -8153,5 +8177,136 @@ nsHttpChannel::SetDoNotTrack()
  }
 }

+
+void
+nsHttpChannel::ReportNetVSCacheTelemetry()
+{
+    nsresult rv;
+    if (!mCacheEntry) {
+        return;
+    }
+
+    // We only report telemetry if the entry is persistent (on disk)
+    bool persistent;
+    rv = mCacheEntry->GetPersistent(&persistent);
+    if (NS_FAILED(rv) || !persistent) {
+        return;
+    }
+
+    nsXPIDLCString tmpStr;
+    rv = mCacheEntry->GetMetaDataElement("net-response-time-onstart",
+                                         getter_Copies(tmpStr));
+    if (NS_FAILED(rv)) {
+        return;
+    }
+    uint64_t onStartNetTime = tmpStr.ToInteger64(&rv);
+    if (NS_FAILED(rv)) {
+        return;
+    }
+
+    tmpStr.Truncate();
+    rv = mCacheEntry->GetMetaDataElement("net-response-time-onstop",
+                                         getter_Copies(tmpStr));
+    if (NS_FAILED(rv)) {
+        return;
+    }
+    uint64_t onStopNetTime = tmpStr.ToInteger64(&rv);
+    if (NS_FAILED(rv)) {
+        return;
+    }
+
+    uint64_t onStartCacheTime = (mOnStartRequestTimestamp - mAsyncOpenTime).ToMilliseconds();
+    int64_t onStartDiff = onStartNetTime - onStartCacheTime;
+    onStartDiff += 500; // We offset the difference by 500 ms to report positive values in telemetry
+
+    uint64_t onStopCacheTime = (mCacheReadEnd - mAsyncOpenTime).ToMilliseconds();
+    int64_t onStopDiff = onStopNetTime - onStopCacheTime;
+    onStopDiff += 500; // We offset the difference by 500 ms
+
+    if (mDidReval) {
+        Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_REVALIDATED, onStartDiff);
+        Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_REVALIDATED, onStopDiff);
+    } else {
+        Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_NOTREVALIDATED, onStartDiff);
+        Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_NOTREVALIDATED, onStopDiff);
+    }
+
+    if (mDidReval) {
+        // We don't report revalidated probes as the data would be skewed.
+        return;
+    }
+
+    uint32_t diskStorageSizeK = 0;
+    rv = mCacheEntry->GetDiskStorageSizeInKB(&diskStorageSizeK);
+    if (NS_FAILED(rv)) {
+        return;
+    }
+
+    nsAutoCString contentType;
+    if (mResponseHead && mResponseHead->HasContentType()) {
+        mResponseHead->ContentType(contentType);
+    }
+    bool isImage = StringBeginsWith(contentType, NS_LITERAL_CSTRING("image/"));
+    if (isImage) {
+        Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_ISIMG, onStartDiff);
+        Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_ISIMG, onStopDiff);
+    } else {
+        Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_NOTIMG, onStartDiff);
+        Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_NOTIMG, onStopDiff);
+    }
+
+    if (mCacheQueueSizeWhenOpen < 10) {
+        if (mCacheOpenWithPriority) {
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_QSMALL_HIGHPRI, onStartDiff);
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_QSMALL_HIGHPRI, onStopDiff);
+        } else {
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_QSMALL_NORMALPRI, onStartDiff);
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_QSMALL_NORMALPRI, onStopDiff);
+        }
+    } else if (mCacheQueueSizeWhenOpen < 50) {
+        if (mCacheOpenWithPriority) {
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_QMED_HIGHPRI, onStartDiff);
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_QMED_HIGHPRI, onStopDiff);
+        } else {
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_QMED_NORMALPRI, onStartDiff);
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_QMED_NORMALPRI, onStopDiff);
+        }
+    } else {
+        if (mCacheOpenWithPriority) {
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_QBIG_HIGHPRI, onStartDiff);
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_QBIG_HIGHPRI, onStopDiff);
+        } else {
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_QBIG_NORMALPRI, onStartDiff);
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_QBIG_NORMALPRI, onStopDiff);
+        }
+    }
+
+    if (diskStorageSizeK < 32) {
+        if (mCacheOpenWithPriority) {
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_SMALL_HIGHPRI, onStartDiff);
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_SMALL_HIGHPRI, onStopDiff);
+        } else {
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_SMALL_NORMALPRI, onStartDiff);
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_SMALL_NORMALPRI, onStopDiff);
+        }
+    } else if (diskStorageSizeK < 256) {
+        if (mCacheOpenWithPriority) {
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_MED_HIGHPRI, onStartDiff);
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_MED_HIGHPRI, onStopDiff);
+        } else {
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_MED_NORMALPRI, onStartDiff);
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_MED_NORMALPRI, onStopDiff);
+        }
+    } else {
+        if (mCacheOpenWithPriority) {
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_LARGE_HIGHPRI, onStartDiff);
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_LARGE_HIGHPRI, onStopDiff);
+        } else {
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTART_LARGE_NORMALPRI, onStartDiff);
+            Telemetry::Accumulate(Telemetry::HTTP_NET_VS_CACHE_ONSTOP_LARGE_NORMALPRI, onStopDiff);
+        }
+    }
+}
+
 } // namespace net
 } // namespace mozilla
--- a/netwerk/protocol/http/nsHttpChannel.h
+++ b/netwerk/protocol/http/nsHttpChannel.h
@ -429,6 +429,9 @@ private:
               rv == NS_ERROR_MALFORMED_URI;
    }

+    // Report net vs cache time telemetry
+    void ReportNetVSCacheTelemetry();
+
    // Create a aggregate set of the current notification callbacks
    // and ensure the transaction is updated to use it.
    void UpdateAggregateCallbacks();
@ -484,6 +487,8 @@ private:
    // auth specific data
    nsCOMPtr<nsIHttpChannelAuthProvider> mAuthProvider;

+    mozilla::TimeStamp                mOnStartRequestTimestamp;
+
    // States of channel interception
    enum {
        DO_NOT_INTERCEPT,  // no interception will occur
@ -513,6 +518,9 @@ private:
    static const uint32_t WAIT_FOR_CACHE_ENTRY = 1;
    static const uint32_t WAIT_FOR_OFFLINE_CACHE_ENTRY = 2;

+    bool                              mCacheOpenWithPriority;
+    uint32_t                          mCacheQueueSizeWhenOpen;
+
    // state flags
    uint32_t                          mCachedContentIsValid     : 1;
    uint32_t                          mCachedContentIsPartial   : 1;
--- a/toolkit/components/telemetry/Histograms.json
+++ b/toolkit/components/telemetry/Histograms.json
@ -1731,6 +1731,294 @@
    "n_values": 12,
    "description": "Whether the URL gets redirected?  (0=200, 1=301, 2=302, 3=304, 4=307, 5=308, 6=400, 7=401, 8=403, 9=404, 10=500, 11=other)"
  },
+  "HTTP_NET_VS_CACHE_ONSTART_ISIMG": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for images. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_NOTIMG": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for non-images. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_ISIMG": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for images. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_NOTIMG": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for non-images. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_QSMALL_NORMALPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for requests with a normal priority and small queue. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_QMED_NORMALPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for requests with a normal priority and medium queue. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_QBIG_NORMALPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for requests with a normal priority and large queue. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_QSMALL_HIGHPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for requests with a high priority and small queue. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_QMED_HIGHPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for requests with a high priority and medium queue. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_QBIG_HIGHPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for requests with a high priority and large queue. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_QSMALL_NORMALPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for requests with a normal priority and small queue. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_QMED_NORMALPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for requests with a normal priority and medium queue. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_QBIG_NORMALPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for requests with a normal priority and large queue. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_QSMALL_HIGHPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for requests with a high priority and small queue. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_QMED_HIGHPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for requests with a high priority and medium queue. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_QBIG_HIGHPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for requests with a high priority and large queue. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_SMALL_NORMALPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for cache files with a small size (<32K) and normal priority. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_MED_NORMALPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for cache files with a medium size (<256K) and normal priority. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_LARGE_NORMALPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for cache files with a large size (>256K) and normal priority. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_SMALL_HIGHPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for cache files with a small size (<32K) and high priority. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_MED_HIGHPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for cache files with a medium size (<256K) and high priority. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_LARGE_HIGHPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) for cache files with a large size (>256K) and high priority. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_SMALL_NORMALPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for cache files with a small size (<32K) and normal priority. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_MED_NORMALPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for cache files with a medium size (<256K) and normal priority. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_LARGE_NORMALPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for cache files with a large size (>256K) and normal priority. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_SMALL_HIGHPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for cache files with a small size (<32K) and high priority. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_MED_HIGHPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for cache files with a medium size (<256K) and high priority. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_LARGE_HIGHPRI": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) for cache files with a large size (>256K) and high priority. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_REVALIDATED": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) revalidated cache entries. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTART_NOTREVALIDATED": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStartRequest) difference (ms) not revalidated cache entries. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_REVALIDATED": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) revalidated cache entries. Offset by 500 ms."
+  },
+  "HTTP_NET_VS_CACHE_ONSTOP_NOTREVALIDATED": {
+    "expires_in_version": "never",
+      "alert_emails": ["necko@mozilla.com"],
+      "bug_numbers": [1313095],
+      "kind": "linear",
+      "high": 1000,
+      "n_buckets": 100,
+      "description": "Network vs cache time load (OnStopRequest) difference (ms) not revalidated cache entries. Offset by 500 ms."
+  },
  "HTTP_AUTH_DIALOG_STATS": {
    "expires_in_version": "never",
    "kind": "enumerated",