request_timing_info.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_REQUEST_TIMING_INFO_H_
#define PAGESPEED_OPT_LOGGING_REQUEST_TIMING_INFO_H_

#include "pagespeed/kernel/base/basictypes.h"

namespace net_instaweb {

class AbstractMutex;
class Timer;

class RequestTimingInfo {
 public:
  RequestTimingInfo(Timer* timer, AbstractMutex* mutex);

  void RequestStarted();

  void ProcessingStarted() { SetToNow(&processing_start_ts_ms_); }

  void ParsingStarted() { SetToNow(&parsing_start_ts_ms_); }

  void FirstByteReturned();

  void PropertyCacheLookupStarted() {
    SetToNow(&pcache_lookup_start_ts_ms_);
  }

  void PropertyCacheLookupFinished() { SetToNow(&pcache_lookup_end_ts_ms_); }

  void RequestFinished() { SetToNow(&end_ts_ms_); }

  void FetchStarted();
  void FetchHeaderReceived();
  void FetchFinished();

  void SetHTTPCacheLatencyMs(int64 latency_ms);
  void SetL2HTTPCacheLatencyMs(int64 latency_ms);

  int64 GetElapsedMs() const;

  bool GetTimeToStartProcessingMs(int64* elapsed_ms) const {
    return GetTimeFromStart(processing_start_ts_ms_, elapsed_ms);
  }

  bool GetProcessingElapsedMs(int64* elapsed_ms) const;

  bool GetTimeToPropertyCacheLookupStartMs(int64* elapsed_ms) const {
    return GetTimeFromStart(pcache_lookup_start_ts_ms_, elapsed_ms);
  }

  bool GetTimeToPropertyCacheLookupEndMs(int64* elapsed_ms) const {
    return GetTimeFromStart(pcache_lookup_end_ts_ms_, elapsed_ms);
  }

  bool GetHTTPCacheLatencyMs(int64* latency_ms) const;
  bool GetL2HTTPCacheLatencyMs(int64* latency_ms) const;

  bool GetTimeToStartFetchMs(int64* elapsed_ms) const;

  bool GetFetchHeaderLatencyMs(int64* latency_ms) const;

  bool GetFetchLatencyMs(int64* latency_ms) const;

  bool GetTimeToFirstByte(int64* latency_ms) const;

  bool GetTimeToStartParseMs(int64* elapsed_ms) const {
    return GetTimeFromStart(parsing_start_ts_ms_, elapsed_ms);
  }

  int64 init_ts_ms() const { return init_ts_ms_; }

  int64 start_ts_ms() const { return start_ts_ms_; }

 private:
  int64 NowMs() const;

  void SetToNow(int64* ts_ms) const;

  bool GetTimeFromStart(int64 ts_ms, int64* elapsed_ms) const;

  Timer* timer_;

  int64 init_ts_ms_;
  int64 start_ts_ms_;
  int64 processing_start_ts_ms_;
  int64 pcache_lookup_start_ts_ms_;
  int64 pcache_lookup_end_ts_ms_;
  int64 parsing_start_ts_ms_;
  int64 end_ts_ms_;

  AbstractMutex* mu_; 
  int64 fetch_start_ts_ms_;
  int64 fetch_header_ts_ms_;
  int64 fetch_end_ts_ms_;
  int64 first_byte_ts_ms_;

  int64 http_cache_latency_ms_;
  int64 l2http_cache_latency_ms_;

  
};

}  

#endif