'Called when the process intializes.'

def run(self):

    while 1:
        now = time()
        try:
            self.redis_conn.ping()
        except:
            logger.error(("skyline    can't    connect    to    redis    at    socket    path    %s" % settings.REDIS_SOCKET_PATH))
            sleep(10)
            self.redis_conn = StrictRedis(unix_socket_path=settings.REDIS_SOCKET_PATH)
            continue
        unique_metrics = list(self.redis_conn.smembers((settings.FULL_NAMESPACE + 'unique_metrics')))
        if (len(unique_metrics) == 0):
            logger.info('no    metrics    in    redis.    try    adding    some    -    see    README')
            sleep(10)
            continue
        pids = []
        for i in range(1, (settings.ANALYZER_PROCESSES + 1)):
            if (i > len(unique_metrics)):
                logger.info('WARNING:    skyline    is    set    for    more    cores    than    needed.')
                break
            p = Process(target=self.spin_process, args=(i, unique_metrics))
            pids.append(p)
            p.start()
        for p in pids:
            p.join()
        exceptions = dict()
        anomaly_breakdown = dict()
        while 1:
            try:
                (key, value) = self.anomaly_breakdown_q.get_nowait()
                if (key not in anomaly_breakdown.keys()):
                    anomaly_breakdown[key] = value
                else:
                    anomaly_breakdown[key] += value
            except Empty:
                break
        while 1:
            try:
                (key, value) = self.exceptions_q.get_nowait()
                if (key not in exceptions.keys()):
                    exceptions[key] = value
                else:
                    exceptions[key] += value
            except Empty:
                break
        if settings.ENABLE_ALERTS:
            for alert in settings.ALERTS:
                for metric in self.anomalous_metrics:
                    if (alert[0] in metric[1]):
                        cache_key = ('last_alert.%s.%s' % (alert[1], metric[1]))
                        try:
                            last_alert = self.redis_conn.get(cache_key)
                            if (not last_alert):
                                self.redis_conn.setex(cache_key, alert[2], packb(metric[0]))
                                trigger_alert(alert, metric)
                        except Exception as e:
                            logger.error(("couldn't    send    alert:    %s" % e))
        filename = path.abspath(path.join(path.dirname(__file__), '..', settings.ANOMALY_DUMP))
        with open(filename, 'w') as fh:
            anomalous_metrics = list(self.anomalous_metrics)
            anomalous_metrics.sort(key=operator.itemgetter(1))
            fh.write(('handle_data(%s)' % anomalous_metrics))
        logger.info(('seconds    to    run                ::    %.2f' % (time() - now)))
        logger.info(('total    metrics                    ::    %d' % len(unique_metrics)))
        logger.info(('total    analyzed                ::    %d' % (len(unique_metrics) - sum(exceptions.values()))))
        logger.info(('total    anomalies            ::    %d' % len(self.anomalous_metrics)))
        logger.info(('exception    stats            ::    %s' % exceptions))
        logger.info(('anomaly    breakdown    ::    %s' % anomaly_breakdown))
        self.send_graphite_metric('skyline.analyzer.run_time', ('%.2f' % (time() - now)))
        self.send_graphite_metric('skyline.analyzer.total_analyzed', ('%.2f' % (len(unique_metrics) - sum(exceptions.values()))))
        raw_series = self.redis_conn.get((settings.FULL_NAMESPACE + settings.CANARY_METRIC))
        if (raw_series is not None):
            unpacker = Unpacker(use_list=False)
            unpacker.feed(raw_series)
            timeseries = list(unpacker)
            time_human = ((timeseries[(-1)][0] - timeseries[0][0]) / 3600)
            projected = ((24 * (time() - now)) / time_human)
            logger.info(('canary    duration            ::    %.2f' % time_human))
            self.send_graphite_metric('skyline.analyzer.duration', ('%.2f' % time_human))
            self.send_graphite_metric('skyline.analyzer.projected', ('%.2f' % projected))
        self.anomalous_metrics[:] = []
        if ((time() - now) < 5):
            logger.info('sleeping    due    to    low    run    time...')
            sleep(10)
