Ejemplo n.º 1
0
        private List <MetricValue> readMetricValuesIntoEntity(BIQEntityBase entity, JobTarget jobTarget, string metricName, AppDRESTMetric appDRESTMetric, int timerangeDuration)
        {
            List <MetricValue> metricValues = new List <MetricValue>(appDRESTMetric.metricValues.Count);

            foreach (AppDRESTMetricValue appDRESTMetricValue in appDRESTMetric.metricValues)
            {
                // Populate metrics into the list for output into CSV
                MetricValue metricValue = new MetricValue();

                metricValue.Controller      = jobTarget.Controller;
                metricValue.ApplicationID   = jobTarget.ApplicationID;
                metricValue.ApplicationName = jobTarget.Application;

                if (entity != null)
                {
                    if (entity is BIQMetric)
                    {
                        BIQMetric metric = (BIQMetric)entity;

                        try { metricValue.EntityID = Convert.ToInt64(metric.MetricID); } catch { }
                        metricValue.EntityName = metric.MetricName;
                        metricValue.EntityType = metric.DataSource;
                    }
                    else if (entity is BIQBusinessJourney)
                    {
                        BIQBusinessJourney businessJourney = (BIQBusinessJourney)entity;

                        // The JourneyID is a hash of some sorts. Let's turn it into unique value
                        metricValue.EntityID   = businessJourney.JourneyID.GetHashCode();
                        metricValue.EntityName = businessJourney.JourneyName;
                        metricValue.EntityType = businessJourney.KeyField;
                    }
                }

                metricValue.EventTimeStampUtc = UnixTimeHelper.ConvertFromUnixTimestamp(appDRESTMetricValue.startTimeInMillis);
                metricValue.EventTimeStamp    = metricValue.EventTimeStampUtc.ToLocalTime();
                metricValue.EventTime         = metricValue.EventTimeStamp;

                metricValue.MetricName = metricName;
                metricValue.MetricID   = appDRESTMetric.metricId;
                switch (appDRESTMetric.frequency)
                {
                case "SIXTY_MIN":
                {
                    metricValue.MetricResolution = 60;
                    break;
                }

                case "TEN_MIN":
                {
                    metricValue.MetricResolution = 10;
                    break;
                }

                case "ONE_MIN":
                {
                    metricValue.MetricResolution = 1;
                    break;
                }

                default:
                {
                    metricValue.MetricResolution = 1;
                    break;
                }
                }

                metricValue.Count       = appDRESTMetricValue.count;
                metricValue.Min         = appDRESTMetricValue.min;
                metricValue.Max         = appDRESTMetricValue.max;
                metricValue.Occurrences = appDRESTMetricValue.occurrences;
                metricValue.Sum         = appDRESTMetricValue.sum;
                metricValue.Value       = appDRESTMetricValue.value;

                metricValues.Add(metricValue);
            }

            return(metricValues);
        }
Ejemplo n.º 2
0
        private List <MetricValue> readMetricsIntoEntities(
            List <AppDRESTMetric> metricData,
            Dictionary <string, BIQEntityBase> entitiesDictionaryByName,
            JobTarget jobTarget,
            JobTimeRange jobTimeRange)
        {
            BIQEntityBase entity = null;

            int timerangeDuration = (int)(jobTimeRange.To - jobTimeRange.From).Duration().TotalMinutes;

            List <MetricValue> metricValues = new List <MetricValue>(metricData.Count * timerangeDuration);

            foreach (AppDRESTMetric appDRESTMetric in metricData)
            {
                if (appDRESTMetric.metricValues.Count == 0)
                {
                    // No metrics in this chunk
                    continue;
                }

                #region Get metric path components and metric name

                // Analyze metric path returned by the call to controller
                string[] metricPathComponents = appDRESTMetric.metricPath.Split('|');

                if (metricPathComponents.Length == 0)
                {
                    // Metric name was no good
                    logger.Warn("Metric path='{0}' could not be parsed into individual components", appDRESTMetric.metricPath);
                    continue;
                }

                string[] metricNameComponents = appDRESTMetric.metricName.Split('|');

                if (metricNameComponents.Length == 0)
                {
                    // Metric name was no good
                    logger.Warn("Metric name='{0}' could not be parsed into individual components", appDRESTMetric.metricName);
                    continue;
                }

                // Name of the metric is always the last one in the metric path
                string metricName = metricPathComponents[metricPathComponents.Length - 1];

                #endregion

                #region Determine metric entity type, scope and name from metric path

                if (metricPathComponents.Length == 2)
                {
                    #region Saved Search/Metric

                    //"metricName" : "Analytics|PolicyAmount - DriverEntry",
                    //"metricPath" : "Analytics|PolicyAmount - DriverEntry",

                    entitiesDictionaryByName.TryGetValue(metricName, out entity);

                    #endregion
                }
                else if (metricPathComponents.Length == 3 && String.Compare(metricPathComponents[1], "Business Journeys", true) == 0)
                {
                    #region Business Journey

                    //"metricName" : "Analytics|Business Journeys|MattTest|Average total time",
                    //"metricPath" : "Analytics|Business Journeys|MattTest|Average total time",

                    entitiesDictionaryByName.TryGetValue(metricPathComponents[2], out entity);

                    #endregion
                }

                #endregion

                List <MetricValue> metricValuesConverted = readMetricValuesIntoEntity(entity, jobTarget, metricName, appDRESTMetric, timerangeDuration);
                metricValues.AddRange(metricValuesConverted);
            }

            return(metricValues);
        }