// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_COMMON_METRICS_METRICS_LOG_MANAGER_H_
#define CHROME_COMMON_METRICS_METRICS_LOG_MANAGER_H_
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "chrome/common/metrics/metrics_log_base.h"
// Manages all the log objects used by a MetricsService implementation. Keeps
// track of both an in progress log and a log that is staged for uploading as
// text, as well as saving logs to, and loading logs from, persistent storage.
class MetricsLogManager {
public:
typedef MetricsLogBase::LogType LogType;
MetricsLogManager();
~MetricsLogManager();
class SerializedLog {
public:
SerializedLog();
~SerializedLog();
const std::string& log_text() const { return log_text_; }
const std::string& log_hash() const { return log_hash_; }
// Returns true if the log is empty.
bool IsEmpty() const;
// Swaps log text with |log_text| and updates the hash. This is more
// performant than a regular setter as it avoids doing a large string copy.
void SwapLogText(std::string* log_text);
// Clears the log.
void Clear();
// Swaps log contents with |other|.
void Swap(SerializedLog* other);
private:
// Non-human readable log text (serialized proto).
std::string log_text_;
// Non-human readable SHA1 of |log_text| or empty if |log_text| is empty.
std::string log_hash_;
// Intentionally omits DISALLOW_COPY_AND_ASSIGN() so that it can be used
// in std::vector<SerializedLog>.
};
enum StoreType {
NORMAL_STORE, // A standard store operation.
PROVISIONAL_STORE, // A store operation that can be easily reverted later.
};
// Takes ownership of |log|, which has type |log_type|, and makes it the
// current_log. This should only be called if there is not a current log.
void BeginLoggingWithLog(MetricsLogBase* log, LogType log_type);
// Returns the in-progress log.
MetricsLogBase* current_log() { return current_log_.get(); }
// Closes current_log(), compresses it, and stores the compressed log for
// later, leaving current_log() NULL.
void FinishCurrentLog();
// Returns true if there are any logs waiting to be uploaded.
bool has_unsent_logs() const {
return !unsent_initial_logs_.empty() || !unsent_ongoing_logs_.empty();
}
// Populates staged_log_text() with the next stored log to send.
// Should only be called if has_unsent_logs() is true.
void StageNextLogForUpload();
// Returns true if there is a log that needs to be, or is being, uploaded.
bool has_staged_log() const;
// The text of the staged log, as a serialized protobuf. Empty if there is no
// staged log, or if compression of the staged log failed.
const std::string& staged_log_text() const { return staged_log_.log_text(); }
// The SHA1 hash (non-human readable) of the staged log or empty if there is
// no staged log.
const std::string& staged_log_hash() const { return staged_log_.log_hash(); }
// Discards the staged log.
void DiscardStagedLog();
// Closes and discards |current_log|.
void DiscardCurrentLog();
// Sets current_log to NULL, but saves the current log for future use with
// ResumePausedLog(). Only one log may be paused at a time.
// TODO(stuartmorgan): Pause/resume support is really a workaround for a
// design issue in initial log writing; that should be fixed, and pause/resume
// removed.
void PauseCurrentLog();
// Restores the previously paused log (if any) to current_log().
// This should only be called if there is not a current log.
void ResumePausedLog();
// Saves the staged log, then clears staged_log().
// If |store_type| is PROVISIONAL_STORE, it can be dropped from storage with
// a later call to DiscardLastProvisionalStore (if it hasn't already been
// staged again).
// This is intended to be used when logs are being saved while an upload is in
// progress, in case the upload later succeeds.
// This can only be called if has_staged_log() is true.
void StoreStagedLogAsUnsent(StoreType store_type);
// Discards the last log stored with StoreStagedLogAsUnsent with |store_type|
// set to PROVISIONAL_STORE, as long as it hasn't already been re-staged. If
// the log is no longer present, this is a no-op.
void DiscardLastProvisionalStore();
// Sets the threshold for how large an onging log can be and still be written
// to persistant storage. Ongoing logs larger than this will be discarded
// before persisting. 0 is interpreted as no limit.
void set_max_ongoing_log_store_size(size_t max_size) {
max_ongoing_log_store_size_ = max_size;
}
// Interface for a utility class to serialize and deserialize logs for
// persistent storage.
class LogSerializer {
public:
virtual ~LogSerializer() {}
// Serializes |logs| to persistent storage, replacing any previously
// serialized logs of the same type.
virtual void SerializeLogs(const std::vector<SerializedLog>& logs,
LogType log_type) = 0;
// Populates |logs| with logs of type |log_type| deserialized from
// persistent storage.
virtual void DeserializeLogs(LogType log_type,
std::vector<SerializedLog>* logs) = 0;
};
// Sets the serializer to use for persisting and loading logs; takes ownership
// of |serializer|.
void set_log_serializer(LogSerializer* serializer) {
log_serializer_.reset(serializer);
}
// Saves any unsent logs to persistent storage using the current log
// serializer. Can only be called after set_log_serializer.
void PersistUnsentLogs();
// Loads any unsent logs from persistent storage using the current log
// serializer. Can only be called after set_log_serializer.
void LoadPersistedUnsentLogs();
private:
// Saves |log| as the given type (or discards it in accordance with
// |max_ongoing_log_store_size_|).
// NOTE: This clears the contents of |log| (to avoid an expensive copy),
// so the log should be discarded after this call.
void StoreLog(SerializedLog* log,
LogType log_type,
StoreType store_type);
// Compresses |current_log_| into |compressed_log|.
void CompressCurrentLog(SerializedLog* compressed_log);
// Tracks whether unsent logs (if any) have been loaded from the serializer.
bool unsent_logs_loaded_;
// The log that we are still appending to.
scoped_ptr<MetricsLogBase> current_log_;
LogType current_log_type_;
// A paused, previously-current log.
scoped_ptr<MetricsLogBase> paused_log_;
LogType paused_log_type_;
// Helper class to handle serialization/deserialization of logs for persistent
// storage. May be NULL.
scoped_ptr<LogSerializer> log_serializer_;
// The current staged log, ready for upload to the server.
SerializedLog staged_log_;
LogType staged_log_type_;
// Logs from a previous session that have not yet been sent.
// Note that the vector has the oldest logs listed first (early in the
// vector), and we'll discard old logs if we have gathered too many logs.
std::vector<SerializedLog> unsent_initial_logs_;
std::vector<SerializedLog> unsent_ongoing_logs_;
size_t max_ongoing_log_store_size_;
// The index and type of the last provisional store. If nothing has been
// provisionally stored, or the last provisional store has already been
// re-staged, the index will be -1;
// This is necessary because during an upload there are two logs (staged
// and current) and a client might store them in either order, so it's
// not necessarily the case that the provisional store is the last store.
int last_provisional_store_index_;
LogType last_provisional_store_type_;
DISALLOW_COPY_AND_ASSIGN(MetricsLogManager);
};
#endif // CHROME_COMMON_METRICS_METRICS_LOG_MANAGER_H_