public function sendMetrics()
{
$metricsKeys = Di::getCache()->getKeys(MetricsCache::getCacheKeySearchLatencyPattern());
$metricsCache = new MetricsCache();
$cachedMetrics = array();
foreach ($metricsKeys as $key) {
$metricName = MetricsCache::getMetricNameFromKey($key);
$metricBucket = MetricsCache::getBucketFromKey($key);
if (!isset($cachedMetrics[$metricName]) || !is_array($cachedMetrics[$metricName])) {
//initialization latency butckets
$maxBucket = Latency::getBucketForLatencyMicros(Latency::MAX_LATENCY);
$cachedMetrics[$metricName] = array_fill(0, $maxBucket + 1, 0);
}
$cachedMetrics[$metricName][$metricBucket] = $metricsCache->getLatencyAndReset($key);
}
$dataset = array();
foreach ($cachedMetrics as $name => $latencies) {
$dataset[] = array('name' => $name, 'latencies' => $latencies);
}
//Sending Metrics dataset.
$response = $this->post($this->servicePath, $dataset);
if ($response->isSuccessful()) {
Di::getLogger()->info(count($dataset) . " Metrics sent successfuly");
} else {
Di::getLogger()->error("Metrics have not been sent successfully");
Di::getLogger()->error("HTTP Code: " . $response->getStatusCode());
Di::getLogger()->error("HTTP Body: " . $response->getBody());
}
}
/**
* @return bool|null
*/
public function getSplitChanges()
{
//Fetching next since value from cache.
$splitCache = new SplitCache();
$since_cached_value = $splitCache->getChangeNumber();
Di::getLogger()->info("SINCE CACHED VALUE: {$since_cached_value}");
$servicePath = $this->servicePath . '?since=' . $since_cached_value;
Di::getLogger()->info("SERVICE PATH: {$servicePath}");
$response = $this->get($servicePath);
if ($response->isSuccessful()) {
$splitChanges = json_decode($response->getBody(), true);
if (isset($splitChanges['since']) && isset($splitChanges['till']) && $splitChanges['since'] == $splitChanges['till']) {
Di::getLogger()->info("Registering splits ready mark");
$dateTimeUTC = new \DateTime("now", new \DateTimeZone("UTC"));
$bur = new BlockUntilReadyCache();
$bur->setReadySplits($dateTimeUTC->getTimestamp());
}
$splits = isset($splitChanges['splits']) ? $splitChanges['splits'] : false;
if (!$splits) {
Di::getLogger()->notice("Splits returned by the server are empty");
return false;
}
return $splitChanges;
}
return false;
}
/**
* @depends testDiLog
*/
public function testDiCache()
{
try {
$cachePoolAdapter = ['name' => 'redis', 'options' => ['host' => REDIS_HOST, 'port' => REDIS_PORT]];
$cachePool = new Pool(['adapter' => $cachePoolAdapter]);
Di::getInstance()->setCache($cachePool);
} catch (\Exception $e) {
$this->assertTrue(false, "Error setting cache on Di");
}
$this->assertTrue(true);
}
public function __construct($apiKey)
{
$serverSDKUrl = SplitIOUtils\getSplitServerUrl();
$serverEventsUrl = SplitIOUtils\getSplitEventsUrl();
$config = new Config();
$config->setUrl($serverSDKUrl);
$config->setEventsUrl($serverEventsUrl);
$config->setAuthorization($apiKey);
$this->config = $config;
//Adding Client configuration as Di value for all Client Resources.
Di::set(Di::KEY_SPLIT_CLIENT_CONFIG, $config);
}
/**
* @return array
*/
public function splits()
{
$_splits = array();
$splitKeys = Di::getCache()->getKeys(SplitCache::getCacheKeySearchPattern());
foreach ($splitKeys as $key) {
$splitView = $this->getSplitByCacheKey($key);
if ($splitView != null) {
$_splits[] = $splitView;
}
}
return $_splits;
}
private function dropDataset($toDrop)
{
try {
$impressionCache = new ImpressionCache();
foreach ($toDrop as $key => $impressions) {
Di::getLogger()->debug("Dropping impressions for key: " . $key);
$impressionCache->removeImpression($key, $impressions);
}
Di::getLogger()->info("Sent Impressions removed from cache successfuly");
} catch (\Exception $e) {
Di::getLogger()->error($e->getMessage());
}
}
public function getSegmentChanges($segmentName)
{
//Fetching next since (till) value from cache.
$segmentCache = new SegmentCache();
$since_cached_value = $segmentCache->getChangeNumber($segmentName);
$servicePath = $this->servicePath . $segmentName . '?since=' . $since_cached_value;
Di::getLogger()->info("SERVICE PATH: {$servicePath}");
try {
//GETting data from server
$response = $this->get($servicePath);
if ($response->isSuccessful()) {
$segment = json_decode($response->getBody(), true);
//Returning false due the server has not changes
if (isset($segment['since']) && isset($segment['till']) && $segment['since'] >= $segment['till']) {
Di::getLogger()->notice("Segments returned by the server are empty");
return false;
}
return $segment;
}
} catch (\Exception $e) {
Di::getLogger()->error($e->getMessage());
}
return false;
}
/**
* Persists a cache item immediately.
*
* @param \SplitIO\Component\Cache\Item $item
* The cache item to save.
*
* @return bool
* True if the item was successfully persisted. False if there was an error.
*/
public function save(Item $item)
{
$key = $item->getKey();
$value = $item->get();
//PSR-6 CacheItemInterface doesn't define a method to get the item expiration value.
$expiration = method_exists($item, 'getExpiration') ? $item->getExpiration() : 0;
if ($this->adapter->save($key, $value, $expiration)) {
Di::getLogger()->debug("Saving cache item: {$key} - {$value} - {$expiration}");
return true;
}
return false;
}
public function __construct()
{
$this->config = Di::get(Di::KEY_SPLIT_CLIENT_CONFIG);
$this->httpTransport = array('transport' => 'Requests_Transport_fsockopen');
$this->resourceType = $this->getResourceType();
}
/**
* @return null|\SplitIO\Component\Cache\Pool
*/
public static function cache()
{
return Di::getCache();
}
/**
* @param $key
* @return mixed|string
*/
public function getLatencyAndReset($key)
{
return Di::getCache()->getSet($key, 0);
}
/**
* @param $segmentName
* @return mixed
*/
public function getChangeNumber($segmentName)
{
$since = Di::getCache()->getItem(self::getCacheKeyForSinceParameter($segmentName))->get();
return empty($since) ? -1 : $since;
}
/**
* @param $key
* @return mixed
*/
private function get($key)
{
$item = Di::getCache()->getItem($key);
$checkpoint = $item->get();
return empty($checkpoint) ? -1 : (int) $checkpoint;
}
/**
* @param string $splitName
* @return string JSON representation
*/
public function getSplit($splitName)
{
$cache = Di::getCache();
$cacheItem = $cache->getItem(self::getCacheKeyForSplit($splitName));
return $cacheItem->get();
}
/**
* @param $key
* @param $value
* @return mixed
*/
public function removeImpression($key, $value)
{
return Di::getCache()->removeItemOnList($key, $value);
}
/**
* Sets the expiration time for this cache item.
*
* @param int|\DateInterval $time
* The period of time from the present after which the item MUST be considered
* expired. An integer parameter is understood to be the time in seconds until
* expiration. If null is passed explicitly, a default value MAY be used.
* If none is set, the value should be stored permanently or for as long as the
* implementation allows.
*
* @return static
* The called object.
*/
public function expiresAfter($time)
{
if ($time instanceof DateInterval) {
$expire = new DateTime();
$expire->add($time);
// convert datetime to unix timestamp
$this->expire = (int) $expire->format('U');
} elseif (is_int($time)) {
$this->expire = time() + $time;
} elseif (is_null($time)) {
$this->expire = 0;
}
Di::getLogger()->info("//--> [CacheItem:{$this->key}] Set expiration time at:\n {$this->expire} - " . date('Y-m-d H:i:s', $this->expire));
return $this;
}
