Java CountMetric类代码示例

import backtype.storm.metric.api.CountMetric; //导入依赖的package包/类
@Override
public void open(Map conf, TopologyContext context,
        SpoutOutputCollector _collector) {
    collector = _collector;
    _spoutMetric = new CountMetric();
    context.registerMetric(CatMetricUtil.getSpoutMetricName(topic, group),  
            _spoutMetric, Constants.EMIT_FREQUENCY_IN_SECONDS);
    
    ConsumerConfig config = new ConsumerConfig();
    try {
        consumer = new Consumer(topic, group, config);
    } catch (LionException e) {
        throw new RuntimeException(e);
    }
    consumer.start();
    stream = consumer.getStream();
    
    fetchThread = new MessageFetcher(stream);
    new Thread(fetchThread).start();
}
 

import backtype.storm.metric.api.CountMetric; //导入依赖的package包/类
@Override
public void open(Map conf, TopologyContext context,
        SpoutOutputCollector _collector) {
    collector = _collector;
    _spoutMetric = new CountMetric();
    context.registerMetric(CatMetricUtil.getSpoutMetricName(topic, group),  
            _spoutMetric, Constants.EMIT_FREQUENCY_IN_SECONDS);
    
    ConsumerConfig config = new ConsumerConfig();
    try {
        consumer = new Consumer(topic, group, config);
    } catch (LionException e) {
        throw new RuntimeException(e);
    }
    consumer.start();
    stream = consumer.getStream();
}
 

import backtype.storm.metric.api.CountMetric; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
  public void registerMetrics(Map conf, IMetricsContext context, String mapStateMetricName) {
      int bucketSize = (Integer) (conf.get(Config.TOPOLOGY_BUILTIN_METRICS_BUCKET_SIZE_SECS));
      String metricBaseName = "cassandra/" + mapStateMetricName;
_mreads = context.registerMetric(metricBaseName + "/readCount", new CountMetric(), bucketSize);
      _mwrites = context.registerMetric(metricBaseName + "/writeCount", new CountMetric(), bucketSize);
      _mexceptions = context.registerMetric(metricBaseName + "/exceptionCount", new CountMetric(), bucketSize);
  }
 

import backtype.storm.metric.api.CountMetric; //导入依赖的package包/类
/**
 * Register Metrics in Storm
 * @param conf A set of properties
 * @param context Metrics context
 */
public void registerMetrics(Map conf, IMetricsContext context) {
    int bucketSize = (Integer) (conf.get(Config.TOPOLOGY_BUILTIN_METRICS_BUCKET_SIZE_SECS));
    _mreads = context.registerMetric("mongodb/readCount", new CountMetric(), bucketSize);
    _mwrites = context.registerMetric("mongodb/writeCount", new CountMetric(), bucketSize);
    _mexceptions = context.registerMetric("mongodb/exceptionCount", new CountMetric(), bucketSize);
}
 

import backtype.storm.metric.api.CountMetric; //导入依赖的package包/类
@Override
public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
    _throttler = new WindowedTimeThrottler((Number) conf.get(Config.TOPOLOGY_TRIDENT_BATCH_EMIT_INTERVAL_MILLIS),
            Integer.MAX_VALUE);
    for (String spoutId : _managedSpoutIds) {
        _states.add(TransactionalState.newCoordinatorState(conf, spoutId));
    }
    _currTransaction = getStoredCurrTransaction();

    _collector = collector;
    Number active = (Number) conf.get(Config.TOPOLOGY_MAX_SPOUT_PENDING);
    if (active == null) {
        _maxTransactionActive = 1;
    } else {
        _maxTransactionActive = active.intValue();
    }
    _attemptIds = getStoredCurrAttempts(_currTransaction, _maxTransactionActive);
    avgWaittingTime = context.registerMetric("commit-wait-ms", new ReducedMetric(new MeanReducer()),
            Utils.getInt(conf.get(Config.TOPOLOGY_BUILTIN_METRICS_BUCKET_SIZE_SECS)));
    commitWaittingCount = context.registerMetric("commit-wait-cnt", new CountMetric(),
            Utils.getInt(conf.get(Config.TOPOLOGY_BUILTIN_METRICS_BUCKET_SIZE_SECS)));
    activeTxCount = context.registerMetric("active-tx-cnt", new ReducedMetric(new MeanReducer()),
            Utils.getInt(conf.get(Config.TOPOLOGY_BUILTIN_METRICS_BUCKET_SIZE_SECS)));
    for (int i = 0; i < _spouts.size(); i++) {
        String txId = _managedSpoutIds.get(i);
        _coordinators.add(_spouts.get(i).getCoordinator(txId, conf, context));
    }
}
 

import backtype.storm.metric.api.CountMetric; //导入依赖的package包/类
@Override
public void prepare(Map config, TopologyContext context) {
  // Optional set logging
  if (config.get(CONF_LOGGING) != null) {
    m_logging = (Boolean) config.get(CONF_LOGGING);
  } else {
    m_logging = false;
  }

  // Tuple counter metric
  if (config.get(CONF_METRIC_LOGGING_INTERVALL) != null) {
    m_countMetric = new CountMetric();
    context.registerMetric("tuple_count", m_countMetric,
        ((Long) config.get(CONF_METRIC_LOGGING_INTERVALL)).intValue());
  }

  LOG.info("Loading SVM model...");
  Dataset dataset = Configuration.getDataSetSemEval2013();
  m_model = SerializationUtils.deserialize(dataset.getDatasetPath()
      + File.separator + SVM.SVM_MODEL_FILE_SER);

  if (m_model == null) {
    LOG.error("Could not load SVM model! File: " + dataset.getDatasetPath()
        + File.separator + SVM.SVM_MODEL_FILE_SER);
    throw new RuntimeException();
  }
}
 

import backtype.storm.metric.api.CountMetric; //导入依赖的package包/类
public PartitionManager(DynamicPartitionConnections connections, String topologyInstanceId, ZkState state, Map stormConf, SpoutConfig spoutConfig, Partition id) {
    _partition = id;
    _connections = connections;
    _spoutConfig = spoutConfig;
    _topologyInstanceId = topologyInstanceId;
    _consumer = connections.register(id.host, id.partition);
    _state = state;
    _stormConf = stormConf;
    numberAcked = numberFailed = 0;

    String jsonTopologyId = null;
    Long jsonOffset = null;
    String path = committedPath();
    try {
        Map<Object, Object> json = _state.readJSON(path);
        LOG.info("Read partition information from: " + path +  "  --> " + json );
        if (json != null) {
            jsonTopologyId = (String) ((Map<Object, Object>) json.get("topology")).get("id");
            jsonOffset = (Long) json.get("offset");
        }
    } catch (Throwable e) {
        LOG.warn("Error reading and/or parsing at ZkNode: " + path, e);
    }

    Long currentOffset = KafkaUtils.getOffset(_consumer, spoutConfig.topic, id.partition, spoutConfig);

    if (jsonTopologyId == null || jsonOffset == null) { // failed to parse JSON?
        _committedTo = currentOffset;
        LOG.info("No partition information found, using configuration to determine offset");
    } else if (!topologyInstanceId.equals(jsonTopologyId) && spoutConfig.forceFromStart) {
        _committedTo = KafkaUtils.getOffset(_consumer, spoutConfig.topic, id.partition, spoutConfig.startOffsetTime);
        LOG.info("Topology change detected and reset from start forced, using configuration to determine offset");
    } else {
        _committedTo = jsonOffset;
        LOG.info("Read last commit offset from zookeeper: " + _committedTo + "; old topology_id: " + jsonTopologyId + " - new topology_id: " + topologyInstanceId );
    }

    if (currentOffset - _committedTo > spoutConfig.maxOffsetBehind || _committedTo <= 0) {
        LOG.info("Last commit offset from zookeeper: " + _committedTo);
        _committedTo = currentOffset;
        LOG.info("Commit offset " + _committedTo + " is more than " +
                spoutConfig.maxOffsetBehind + " behind, resetting to startOffsetTime=" + spoutConfig.startOffsetTime);
    }

    LOG.info("Starting Kafka " + _consumer.host() + ":" + id.partition + " from offset " + _committedTo);
    _emittedToOffset = _committedTo;

    _fetchAPILatencyMax = new CombinedMetric(new MaxMetric());
    _fetchAPILatencyMean = new ReducedMetric(new MeanReducer());
    _fetchAPICallCount = new CountMetric();
    _fetchAPIMessageCount = new CountMetric();
}
 

import backtype.storm.metric.api.CountMetric; //导入依赖的package包/类
@Override
public void execute(Tuple input) {

    // triggered by the arrival of a tuple
    // be it a tick or normal one
    flushQueues();

    if (isTickTuple(input)) {
        return;
    }

    CountMetric metric = metricGauge.scope("activethreads");
    metric.getValueAndReset();
    metric.incrBy(this.activeThreads.get());

    metric = metricGauge.scope("in queues");
    metric.getValueAndReset();
    metric.incrBy(this.fetchQueues.inQueues.get());

    metric = metricGauge.scope("queues");
    metric.getValueAndReset();
    metric.incrBy(this.fetchQueues.queues.size());

    LOG.info("[Fetcher #{}] Threads : {}\tqueues : {}\tin_queues : {}",
            taskIndex, this.activeThreads.get(),
            this.fetchQueues.queues.size(), this.fetchQueues.inQueues.get());

    if (!input.contains("url")) {
        LOG.info("[Fetcher #{}] Missing field url in tuple {}", taskIndex,
                input);
        // ignore silently
        _collector.ack(input);
        return;
    }

    String url = input.getStringByField("url");

    // has one but what about the content?
    if (StringUtils.isBlank(url)) {
        LOG.info("[Fetcher #{}] Missing value for field url in tuple {}",
                taskIndex, input);
        // ignore silently
        _collector.ack(input);
        return;
    }

    fetchQueues.addFetchItem(input);
}
 

import backtype.storm.metric.api.CountMetric; //导入依赖的package包/类
private void initMetrics(TopologyContext context)
{
    _countMetric = new CountMetric();
    
    context.registerMetric("record_count", _countMetric, 1);
}
 

import backtype.storm.metric.api.CountMetric; //导入依赖的package包/类
public PartitionManager(DynamicPartitionConnections connections, String topologyInstanceId, ZkState state, Map stormConf, SpoutConfig spoutConfig, Partition id) {
    _partition = id;
    _connections = connections;
    _spoutConfig = spoutConfig;
    _topologyInstanceId = topologyInstanceId;
    _consumer = connections.register(id.host, id.partition);
    _state = state;
    _stormConf = stormConf;

    String jsonTopologyId = null;
    Long jsonOffset = null;
    String path = committedPath();
    try {
        Map<Object, Object> json = _state.readJSON(path);
        LOG.info("Read partition information from: " + path +  " --> " + json );
        if (json != null) {
            jsonTopologyId = (String) ((Map<Object, Object>) json.get("topology")).get("id");
            jsonOffset = (Long) json.get("offset");
        }
    } catch (Throwable e) {
        LOG.warn("Error reading and/or parsing at ZkNode: " + path, e);
    }

    if (jsonTopologyId == null || jsonOffset == null) { // failed to parse JSON?
        _committedTo = KafkaUtils.getOffset(_consumer, spoutConfig.topic, id.partition, spoutConfig);
        LOG.info("No partition information found, using configuration to determine offset");
    } else if (!topologyInstanceId.equals(jsonTopologyId) && spoutConfig.forceFromStart) {
        _committedTo = KafkaUtils.getOffset(_consumer, spoutConfig.topic, id.partition, spoutConfig.startOffsetTime);
        LOG.info("Topology change detected and reset from start forced, using configuration to determine offset");
    } else {
        _committedTo = jsonOffset;
        LOG.info("Read last commit offset from zookeeper: " + _committedTo + "; old topology_id: " + jsonTopologyId + " - new topology_id: " + topologyInstanceId );
    }

    LOG.info("Starting " + _partition + " from offset " + _committedTo);
    _emittedToOffset = _committedTo;

    _fetchAPILatencyMax = new CombinedMetric(new MaxMetric());
    _fetchAPILatencyMean = new ReducedMetric(new MeanReducer());
    _fetchAPICallCount = new CountMetric();
    _fetchAPIMessageCount = new CountMetric();
}
 

import backtype.storm.metric.api.CountMetric; //导入依赖的package包/类
@Override
public void prepare(@SuppressWarnings("rawtypes") Map stormNativeConfig,
		TopologyContext context, OutputCollector collector) {
	this.stormNativeConfig = stormNativeConfig;
	this.collector = collector;
	originId = operationClass.getName() + "." + context.getThisTaskIndex();

	// connect to the zoopkeeper configuration
	try {
		zookeeperStormConfiguration = ZookeeperStormConfigurationFactory
				.getInstance().getStormConfiguration(stormNativeConfig);
	} catch (StormConfigurationException e) {
		logger.error("Can not connect to zookeeper for get Storm configuration. Reason: "
				+ e.getMessage());
		// create empty config to avoid errors
		zookeeperStormConfiguration = new EmptyStormConfiguration();
	}

	String msg = "SensorStormBolt instance created for";
	if (fieldGrouperId == null) {
		msg = msg + " a single_instance operation class \""
				+ operationClass.getName() + "\"";
	} else {
		msg = msg + " a fieldGrouping operation class \""
				+ operationClass.getName() + "\" grouped on tuple field \""
				+ fieldGrouperId + "\"";
	}
	if (batcherClass != null) {
		msg = msg + ", with a batcher class \"" + batcherClass.getName()
				+ "\"";
	} else {
		msg = msg + ", with no batcher.";
	}
	logger.info(msg);
	syncBuffer = new FlushingSyncBuffer(syncBufferSize);
	operationManagers = new HashMap<String, OperationManager>();
	fieldGrouperValues = new HashMap<Particle, String>();
	bufferRejectMetric = new CountMetric();
	context.registerMetric("syncbuffer_rejects", bufferRejectMetric,
			TIME_BUCKET_SIZE_IN_SECS);
}