log_record.h

Go to the documentation of this file.

/*
 * Copyright 2012 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef PAGESPEED_OPT_LOGGING_LOG_RECORD_H_
#define PAGESPEED_OPT_LOGGING_LOG_RECORD_H_

#include <map>
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/gtest_prod.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/http/image_types.pb.h"
#include "pagespeed/opt/logging/enums.pb.h"
#include "pagespeed/opt/logging/logging_proto.h"
#include "pagespeed/opt/logging/logging_proto_impl.h"


namespace net_instaweb {

class AbstractMutex;
class RequestTimingInfo;


class AbstractLogRecord  {
 public:
  explicit AbstractLogRecord(AbstractMutex* mutex);
  virtual ~AbstractLogRecord();

  GoogleString AppliedRewritersString();

  RewriterInfo* NewRewriterInfo(const char* rewriter_id);

  void SetRewriterLoggingStatus(
      const char* rewriter_id, RewriterApplication::Status status);

  void SetRewriterLoggingStatus(
      const char* rewriter_id, const GoogleString& url,
      RewriterApplication::Status status) {
    SetRewriterLoggingStatusHelper(rewriter_id, url, status);
  }

  void LogRewriterHtmlStatus(const char* rewriter_id,
                             RewriterHtmlApplication::Status status);

  void LogRewriterApplicationStatus(
      const char* rewriter_id, RewriterApplication::Status status);

  virtual LoggingInfo* logging_info() = 0;


  void LogImageBackgroundRewriteActivity(
      RewriterApplication::Status status,
      const GoogleString& url,
      const char* id,
      int original_size,
      int optimized_size,
      bool is_recompressed,
      ImageType original_image_type,
      ImageType optimized_image_type,
      bool is_resized,
      int original_width,
      int original_height,
      bool is_resized_using_rendered_dimensions,
      int resized_width,
      int resized_height);

  void SetIsHtml(bool is_html);

  virtual void AddFoundPropertyToCohortInfo(
      int page_type, const GoogleString& cohort,
      const GoogleString& property) = 0;

  virtual void AddRetrievedPropertyToCohortInfo(
      int page_type, const GoogleString& cohort,
      const GoogleString& property) = 0;

  virtual void SetCacheStatusForCohortInfo(
      int page_type, const GoogleString& cohort,
      bool found, int key_state) = 0;

  void SetIsOriginalResourceCacheable(bool cacheable);

  virtual void LogImageRewriteActivity(
      const char* id,
      const GoogleString& url,
      RewriterApplication::Status status,
      bool is_image_inlined,
      bool is_critical_image,
      bool is_url_rewritten,
      int size,
      bool try_low_res_src_insertion,
      bool low_res_src_inserted,
      ImageType low_res_image_type,
      int low_res_data_size) = 0;

  void LogJsDisableFilter(const char* id, bool has_pagespeed_no_defer);

  void LogLazyloadFilter(const char* id,
                         RewriterApplication::Status status,
                         bool is_blacklisted, bool is_critical);

  bool WriteLog();

  AbstractMutex* mutex() { return mutex_.get(); }

  void SetRewriterInfoMaxSize(int x);

  void SetAllowLoggingUrls(bool allow_logging_urls);

  void SetLogUrlIndices(bool log_url_indices);

  void SetNumHtmlCriticalImages(int num_html_critical_images);

  void SetNumCssCriticalImages(int num_css_critical_images);

  virtual void SetImageStats(int num_img_tags, int num_inlined_img_tags,
                             int num_critical_images_used) = 0;

  virtual void SetResourceCounts(int num_external_css, int num_scripts) = 0;

  void SetCriticalCssInfo(int critical_inlined_bytes,
                          int original_external_bytes,
                          int overhead_bytes);

  virtual void LogDeviceInfo(
      int device_type,
      bool supports_image_inlining,
      bool supports_lazyload_images,
      bool supports_critical_images_beacon,
      bool supports_deferjs,
      bool supports_webp_in_place,
      bool supports_webp_rewritten_urls,
      bool supports_webplossless_alpha,
      bool is_bot) = 0;

  void LogIsXhr(bool is_xhr);

  virtual void SetBackgroundRewriteInfo(
    bool log_urls,
    bool log_url_indices,
    int max_rewrite_info_log_size);

  virtual void SetTimingInfo(const RequestTimingInfo& timing_info) {}

 protected:
  virtual bool WriteLogImpl() = 0;

  RewriterInfo* SetRewriterLoggingStatusHelper(
      const char* rewriter_id, const GoogleString& url,
      RewriterApplication::Status status);

 private:
  void InitLogging();

  void PopulateUrl(
      const GoogleString& url, RewriteResourceInfo* rewrite_resource_info);

  void PopulateRewriterStatusCounts();

  scoped_ptr<AbstractMutex> mutex_;

  int rewriter_info_max_size_;

  bool allow_logging_urls_;

  bool log_url_indices_;

  StringIntMap url_index_map_;

  typedef std::map<RewriterApplication::Status, int> RewriteStatusCountMap;
  struct RewriterStatsInternal {
    RewriterHtmlApplication::Status html_status;

    RewriteStatusCountMap status_counts;

    RewriterStatsInternal()
        : html_status(RewriterHtmlApplication::UNKNOWN_STATUS) {}
  };
  typedef std::map<GoogleString, RewriterStatsInternal> RewriterStatsMap;
  RewriterStatsMap rewriter_stats_;

  
};

class LogRecord : public AbstractLogRecord {
 public:
  explicit LogRecord(AbstractMutex* mutex);

  virtual ~LogRecord();

  LoggingInfo* logging_info() { return logging_info_.get(); }

  virtual void SetImageStats(int num_img_tags, int num_inlined_img_tags,
                             int num_critical_images_used) {}

  virtual void SetResourceCounts(int num_external_css, int num_scripts) {}

  virtual void AddFoundPropertyToCohortInfo(
      int page_type, const GoogleString& cohort,
      const GoogleString& property) {}

  virtual void AddRetrievedPropertyToCohortInfo(
      int page_type, const GoogleString& cohort,
      const GoogleString& property) {}

  void SetCacheStatusForCohortInfo(
      int page_type, const GoogleString& cohort, bool found, int key_state) {}

  virtual void LogImageRewriteActivity(
      const char* id,
      const GoogleString& url,
      RewriterApplication::Status status,
      bool is_image_inlined,
      bool is_critical_image,
      bool is_url_rewritten,
      int size,
      bool try_low_res_src_insertion,
      bool low_res_src_inserted,
      ImageType low_res_image_type,
      int low_res_data_size) {}

  void LogDeviceInfo(
      int device_type,
      bool supports_image_inlining,
      bool supports_lazyload_images,
      bool supports_critical_images_beacon,
      bool supports_deferjs,
      bool supports_webp_in_place,
      bool supports_webp_rewritten_urls,
      bool supports_webplossless_alpha,
      bool is_bot) override {}

  bool WriteLogImpl() override { return true; }

 private:
  scoped_ptr<LoggingInfo> logging_info_;
};

class CopyOnWriteLogRecord : public LogRecord {
 public:
  CopyOnWriteLogRecord(AbstractMutex* logging_mutex, LoggingInfo* logging_info)
      : LogRecord(logging_mutex), logging_info_copy_(logging_info) {}

 protected:
  virtual bool WriteLogImpl() {
    logging_info_copy_->CopyFrom(*logging_info());
    return true;
  }

 private:
  LoggingInfo* logging_info_copy_; 

  
};

}  

#endif