private static Sensor ThroughputAndLatencySensor(TaskId taskId,
                                                         string storeType,
                                                         string storeName,
                                                         string metricName,
                                                         string metricDescription,
                                                         string descriptionOfRate,
                                                         string descriptionOfAvg,
                                                         string descriptionOfMax,
                                                         MetricsRecordingLevel recordingLevel,
                                                         StreamMetricsRegistry streamsMetrics)
        {
            Sensor sensor;
            string latencyMetricName          = metricName + StreamMetricsRegistry.LATENCY_SUFFIX;
            IDictionary <string, string> tags =
                streamsMetrics.StoreLevelTags(GetThreadId(), taskId.ToString(), storeName, storeType);

            sensor = streamsMetrics.StoreLevelSensor(GetThreadId(), taskId, storeName, metricName, metricDescription, recordingLevel);
            SensorHelper.AddInvocationRateToSensor(sensor, StreamMetricsRegistry.STATE_STORE_LEVEL_GROUP, tags, metricName,
                                                   descriptionOfRate);

            SensorHelper.AddAvgAndMaxToSensor(
                sensor,
                StreamMetricsRegistry.STATE_STORE_LEVEL_GROUP,
                tags,
                latencyMetricName,
                descriptionOfAvg,
                descriptionOfMax
                );
            return(sensor);
        }
        private static Sensor SizeOrCountSensor(TaskId taskId,
                                                string storeType,
                                                string storeName,
                                                string metricName,
                                                string metricDescription,
                                                string descriptionOfAvg,
                                                string descriptionOfMax,
                                                MetricsRecordingLevel recordingLevel,
                                                StreamMetricsRegistry streamsMetrics)
        {
            Sensor sensor = streamsMetrics.StoreLevelSensor(
                GetThreadId(),
                taskId,
                storeName,
                metricName,
                metricDescription,
                recordingLevel);
            string group;
            IDictionary <string, string> tags;

            group = StreamMetricsRegistry.STATE_STORE_LEVEL_GROUP;
            tags  = streamsMetrics.StoreLevelTags(GetThreadId(), taskId.ToString(), storeName, storeType);

            SensorHelper.AddAvgAndMaxToSensor(sensor, group, tags, metricName, descriptionOfAvg, descriptionOfMax);

            return(sensor);
        }
示例#3
0
        private static Sensor ThroughputSensor(string threadId,
                                               TaskId taskId,
                                               string processorNodeId,
                                               string metricNamePrefix,
                                               string metricDescription,
                                               string descriptionOfRate,
                                               string descriptionOfCount,
                                               MetricsRecordingLevel recordingLevel,
                                               StreamMetricsRegistry metricsRegistry)
        {
            Sensor sensor =
                metricsRegistry.NodeLevelSensor(threadId, taskId, processorNodeId, metricNamePrefix, metricDescription,
                                                recordingLevel);
            var tags = metricsRegistry.NodeLevelTags(threadId, taskId.ToString(), processorNodeId);

            SensorHelper.AddInvocationRateAndCountToSensor(
                sensor,
                StreamMetricsRegistry.PROCESSOR_NODE_LEVEL_GROUP,
                tags,
                metricNamePrefix,
                descriptionOfRate,
                descriptionOfCount
                );
            return(sensor);
        }
        public static Sensor ProcessSensor(string threadId, TaskId taskId, StreamMetricsRegistry metricsRegistry)
        {
            Sensor sensor = metricsRegistry.TaskLevelSensor(threadId, taskId, PROCESS, PROCESS_DESCRIPTION, MetricsRecordingLevel.DEBUG);

            SensorHelper.AddInvocationRateAndCountToSensor(
                sensor,
                StreamMetricsRegistry.TASK_LEVEL_GROUP,
                metricsRegistry.TaskLevelTags(threadId, taskId.ToString()),
                PROCESS,
                PROCESS_RATE_DESCRIPTION,
                PROCESS_TOTAL_DESCRIPTION
                );
            return(sensor);
        }
        public static Sensor ActiveRestorationSensor(string threadId,
                                                     TaskId taskId,
                                                     StreamMetricsRegistry metricsRegistry)
        {
            Sensor sensor = metricsRegistry.TaskLevelSensor(threadId, taskId, ACTIVE_RESTORATION, ACTIVE_RESTORATION_DESCRIPTION, MetricsRecordingLevel.DEBUG);

            SensorHelper.AddValueMetricToSensor(
                sensor,
                StreamMetricsRegistry.TASK_LEVEL_GROUP,
                metricsRegistry.TaskLevelTags(threadId, taskId.ToString()),
                ACTIVE_RESTORATION,
                ACTIVE_RESTORATION_DESCRIPTION
                );

            return(sensor);
        }
        public static Sensor ActiveBufferedRecordsSensor(
            string threadId,
            TaskId taskId,
            StreamMetricsRegistry metricsRegistry)
        {
            string name   = ACTIVE_TASK_PREFIX + BUFFER_COUNT;
            Sensor sensor = metricsRegistry.TaskLevelSensor(threadId, taskId, name, name, MetricsRecordingLevel.DEBUG);

            SensorHelper.AddValueMetricToSensor(
                sensor,
                StreamMetricsRegistry.TASK_LEVEL_GROUP,
                metricsRegistry.TaskLevelTags(threadId, taskId.ToString()),
                name,
                NUM_BUFFERED_RECORDS_DESCRIPTION
                );

            return(sensor);
        }
        private static Sensor InvocationRateAndCountSensor(string threadId,
                                                           TaskId taskId,
                                                           string metricName,
                                                           string metricDescription,
                                                           string descriptionOfRate,
                                                           string descriptionOfCount,
                                                           MetricsRecordingLevel recordingLevel,
                                                           StreamMetricsRegistry streamsMetrics)
        {
            Sensor sensor =
                streamsMetrics.TaskLevelSensor(threadId, taskId, metricName, metricDescription, recordingLevel);

            SensorHelper.AddInvocationRateAndCountToSensor(
                sensor,
                StreamMetricsRegistry.TASK_LEVEL_GROUP,
                streamsMetrics.TaskLevelTags(threadId, taskId.ToString()),
                metricName,
                descriptionOfRate,
                descriptionOfCount
                );

            return(sensor);
        }
        private static Sensor AvgAndMaxSensor(string threadId,
                                              TaskId taskId,
                                              string metricName,
                                              string metricDescription,
                                              string descriptionOfAvg,
                                              string descriptionOfMax,
                                              MetricsRecordingLevel recordingLevel,
                                              StreamMetricsRegistry streamsMetrics)
        {
            Sensor sensor =
                streamsMetrics.TaskLevelSensor(threadId, taskId, metricName, metricDescription, recordingLevel);
            var tags = streamsMetrics.TaskLevelTags(threadId, taskId.ToString());

            SensorHelper.AddAvgAndMaxToSensor(
                sensor,
                StreamMetricsRegistry.TASK_LEVEL_GROUP,
                tags,
                metricName,
                descriptionOfAvg,
                descriptionOfMax
                );

            return(sensor);
        }
        public static Sensor ExpiredWindowRecordDropSensor(TaskId taskId,
                                                           string storeType,
                                                           string storeName,
                                                           StreamMetricsRegistry streamsMetrics)
        {
            Sensor sensor = streamsMetrics.StoreLevelSensor(
                GetThreadId(),
                taskId,
                storeName,
                EXPIRED_WINDOW_RECORD_DROP,
                EXPIRED_WINDOW_RECORD_DROP_DESCRIPTION,
                MetricsRecordingLevel.INFO
                );

            SensorHelper.AddInvocationRateAndCountToSensor(
                sensor,
                "stream-" + storeType + "-metrics",
                streamsMetrics.StoreLevelTags(GetThreadId(), taskId.ToString(), storeName, storeType),
                EXPIRED_WINDOW_RECORD_DROP,
                EXPIRED_WINDOW_RECORD_DROP_RATE_DESCRIPTION,
                EXPIRED_WINDOW_RECORD_DROP_TOTAL_DESCRIPTION
                );
            return(sensor);
        }