com.codahale.metrics.graphite.Graphite#com.codahale.metrics.ConsoleReporter源码实例Demo

/**
 * Print out reports from the executed tests.
 */
public void printReport() {
  ScheduledReporter reporter = freonCommand.isInteractive()
      ? ConsoleReporter.forRegistry(metrics).build()
      : Slf4jReporter.forRegistry(metrics).build();
  reporter.report();

  List<String> messages = new LinkedList<>();
  messages.add("Total execution time (sec): " +
      Math.round((System.currentTimeMillis() - startTime) / 1000.0));
  messages.add("Failures: " + failureCounter.get());
  messages.add("Successful executions: " + successCounter.get());

  Consumer<String> print = freonCommand.isInteractive()
      ? System.out::println
      : LOG::info;
  messages.forEach(print);
}
 

public static void main(final String[] args) {
    if (args.length < 3) {
        LOG.error("[initialServerList], [configPath] are needed.");
    }
    final String initialServerList = args[1];
    final String configPath = args[2];

    final RheaKVStoreOptions opts = Yaml.readConfig(configPath);
    opts.setInitialServerList(initialServerList);

    final Node node = new Node(opts);
    node.start();

    ConsoleReporter.forRegistry(KVMetrics.metricRegistry()) //
            .build() //
            .start(30, TimeUnit.SECONDS);

    Runtime.getRuntime().addShutdownHook(new Thread(node::stop));
    LOG.info("BenchmarkServer start OK, options: {}", opts);
}
 

private void startLoggingMetrics(final File diagnosticFolder) {
    final File metricLog = new File(diagnosticFolder, FILE_NAME_METRIC_LOG);

    try {
        final PrintStream logStream = new PrintStream(metricLog, Charset.defaultCharset().name());
        final ConsoleReporter metricReporter = ConsoleReporter.forRegistry(metricRegistry)
                .convertRatesTo(TimeUnit.SECONDS)
                .convertDurationsTo(TimeUnit.MILLISECONDS)
                .outputTo(logStream)
                .build();
        metricReporter.start(1, TimeUnit.SECONDS);

    } catch (final IOException e) {
        log.error("Not able to create metric.log, for {}", e.getCause());
    }
}
 

/**
 * Start metrics reporter.
 *
 */
protected void startReporter() {
  switch (cxt.conf.reporter) {
    case "console":
      consoleReporter = ConsoleReporter.forRegistry(cxt.register)
                            .convertRatesTo(TimeUnit.SECONDS)
                            .convertDurationsTo(TimeUnit.MILLISECONDS)
                            .build();
      consoleReporter.start(cxt.conf.report_interval, TimeUnit.SECONDS);
      break;
    case "jmx":
      jmxReporter = JmxReporter.forRegistry(cxt.register).build();
      jmxReporter.start();
      break;
    default:
      break;
  }
}
 

public static void main(String args[]) throws IOException, InterruptedException {
	ConsoleReporter reporter = ConsoleReporter.forRegistry(metrics).convertRatesTo(TimeUnit.SECONDS)
			.convertDurationsTo(TimeUnit.MILLISECONDS).build();
	metrics.register("jvm.mem", new MemoryUsageGaugeSet());
	metrics.register("jvm.gc", new GarbageCollectorMetricSet());
	reporter.start(5, TimeUnit.SECONDS);

	String hostName = "192.168.66.29";
	ZabbixSender zabbixSender = new ZabbixSender("192.168.90.102", 10051);
	ZabbixReporter zabbixReporter = ZabbixReporter.forRegistry(metrics).hostName(hostName).prefix("test.")
			.build(zabbixSender);

	zabbixReporter.start(1, TimeUnit.SECONDS);

	TimeUnit.SECONDS.sleep(500);
}
 

public void startReporting() {
    if (reporterName.equalsIgnoreCase("console")) {
        reporter = ConsoleReporter.forRegistry(metricRegistry)
                .convertRatesTo(TimeUnit.SECONDS)
                .convertDurationsTo(TimeUnit.MILLISECONDS)
                .build();
        ((ConsoleReporter) reporter).start(interval, TimeUnit.SECONDS);
    } else if (reporterName.equalsIgnoreCase("jmx")) {
        reporter = JmxReporter.forRegistry(metricRegistry)
                .convertRatesTo(TimeUnit.SECONDS)
                .convertDurationsTo(TimeUnit.MILLISECONDS)
                .build();
        ((JmxReporter) reporter).start();
    } else {
        throw new UnsupportedOperationException("Only 'ConsoleReporter' and 'JmxReporter' is supported, Reporter " +
                "type '" + reporter.getClass().getName() + "' is not supported");
    }
}
 

public static void main(String[] args) throws Exception {
    MetricRegistry metrics = new MetricRegistry();
    ConsoleReporter reporter = PerformanceHelper.consoleReporter(metrics);
    Timer timer = metrics.timer("allocations");

    Random random = new Random(System.nanoTime());
    int iterations = 1000000;
    MemoryPointer[] pointerArray = new MemoryPointer[iterations];

    for (int i = 0; i < pointerArray.length; i++) {
        Timer.Context watch = timer.time();
        pointerArray[i] = MemoryAllocator.allocate(random.nextInt(16384));
        watch.stop();
    }

    reporter.report();
}
 

public static void main(String[] args) {
    MetricRegistry metrics = new MetricRegistry();
    ConsoleReporter reporter = PerformanceHelper.consoleReporter(metrics);
    Timer timer = metrics.timer("reads");
    TupleGenerator generator = new TupleGenerator();
    List<Tuple> tuples = generator.testRecords(1, 64000, 20, 16, 100);

    TupleBlock.Builder blockBuilder = new TupleBlock.Builder();
    for (Tuple tuple : tuples) {
        blockBuilder.addRecord(tuple);
    }

    TupleBlock block = blockBuilder.build();

    Random random = new Random(System.nanoTime());
    int iterations = 10000000;

    for (int i = 0; i < iterations; i++) {
        Timer.Context watch = timer.time();
        block.get(tuples.get(random.nextInt(tuples.size())).key());
        watch.stop();
    }

    reporter.report();
}
 

public static void main(String[] args) throws Exception {
    MetricRegistry metrics = new MetricRegistry();
    ConsoleReporter reporter = PerformanceHelper.consoleReporter(metrics);
    Timer timer = metrics.timer("writes");

    TestFileHelper.createTestDirectory();
    KeyValueGenerator keyValueGenerator = new KeyValueGenerator();
    Value value = new Value(keyValueGenerator.testValue(100));

    DBState state = ConfigGenerator.perfState();
    TableWriter tableWriter = new TableWriter(state.config(), state.paths(), state.tables(), state.snapshots(),
            state.caches(), new Metrics(state.config()));

    for (int i = 0; i < RECORD_COUNT; i++) {
        value.data().rewind();
        Timer.Context watch = timer.time();
        tableWriter.write(ByteBuffers.fromString(i + ""), value.data(), false);
        watch.stop();
    }

    reporter.report();
    tableWriter.close();

    TestFileHelper.cleanUpTestFiles();
}
 

public synchronized void initReporting(Reporting reporting) {
  if(!reportingInitialized) {
    switch(reporting) {
      case CONSOLE:
        final ConsoleReporter consoleReporter = ConsoleReporter.forRegistry(SentryMetricsServletContextListener.METRIC_REGISTRY)
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build();
        consoleReporter.start(1, TimeUnit.SECONDS);
        break;
      case JMX:
        final JmxReporter jmxReporter = JmxReporter.forRegistry(SentryMetricsServletContextListener.METRIC_REGISTRY)
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build();
        jmxReporter.start();
        break;
    }
  }
}
 

@Override
public List<AutoCloseable> start(Params params) {
  SimpleConfiguration config =
      new FluoConfiguration(params.getConfiguration()).getReporterConfiguration("console");

  if (!config.getBoolean("enable", false)) {
    return Collections.emptyList();
  }

  TimeUnit rateUnit = TimeUnit.valueOf(config.getString("rateUnit", "seconds").toUpperCase());
  TimeUnit durationUnit =
      TimeUnit.valueOf(config.getString("durationUnit", "milliseconds").toUpperCase());
  PrintStream out = System.out;
  if (config.getString("target", "stdout").equals("stderr")) {
    out = System.err;
  }

  ConsoleReporter reporter = ConsoleReporter.forRegistry(params.getMetricRegistry())
      .convertDurationsTo(durationUnit).convertRatesTo(rateUnit).outputTo(out).build();
  reporter.start(config.getInt("frequency", 60), TimeUnit.SECONDS);

  log.info("Reporting metrics to console");

  return Collections.singletonList((AutoCloseable) reporter);
}
 

public AtomicRangeGroup(String dataPath, String groupId, PeerId serverId, long minSlot, long maxSlot,
                        NodeOptions nodeOptions, RpcServer rpcServer) throws IOException {
    // Init file path
    FileUtils.forceMkdir(new File(dataPath));
    this.minSlot = minSlot;
    this.maxSlot = maxSlot;

    // Init statemachine
    this.fsm = new AtomicStateMachine();

    // Set statemachine to bootstrap options
    nodeOptions.setFsm(this.fsm);
    nodeOptions.setEnableMetrics(true);
    nodeOptions.getRaftOptions().setReplicatorPipeline(true);
    nodeOptions.getRaftOptions().setSync(true);
    nodeOptions.getRaftOptions().setReadOnlyOptions(ReadOnlyOption.ReadOnlySafe);

    // Set the data path
    // Log, required
    nodeOptions.setLogUri(dataPath + File.separator + "log");
    // Metadata, required
    nodeOptions.setRaftMetaUri(dataPath + File.separator + "raft_meta");
    // Snapshot, not required, but recommend
    nodeOptions.setSnapshotUri(dataPath + File.separator + "snapshot");
    // Init raft group service framework
    this.raftGroupService = new RaftGroupService(groupId, serverId, nodeOptions, rpcServer);
    // Startup node
    this.node = this.raftGroupService.start();

    final ConsoleReporter reporter = ConsoleReporter.forRegistry(node.getNodeMetrics().getMetricRegistry())
        .convertRatesTo(TimeUnit.SECONDS).convertDurationsTo(TimeUnit.MILLISECONDS).build();
    reporter.start(60, TimeUnit.SECONDS);

}
 

@Test
public void testNodeMetrics() throws Exception {
    final List<PeerId> peers = TestUtils.generatePeers(3);

    final TestCluster cluster = new TestCluster("unittest", this.dataPath, peers);
    for (final PeerId peer : peers) {
        assertTrue(cluster.start(peer.getEndpoint(), false, 300, true));
    }

    // elect leader
    cluster.waitLeader();

    // get leader
    final Node leader = cluster.getLeader();
    assertNotNull(leader);
    assertEquals(3, leader.listPeers().size());
    // apply tasks to leader
    this.sendTestTaskAndWait(leader);

    {
        final ByteBuffer data = ByteBuffer.wrap("no closure".getBytes());
        final Task task = new Task(data, null);
        leader.apply(task);
    }

    cluster.ensureSame(-1);
    for (final Node node : cluster.getNodes()) {
        System.out.println("-------------" + node.getNodeId() + "-------------");
        final ConsoleReporter reporter = ConsoleReporter.forRegistry(node.getNodeMetrics().getMetricRegistry())
            .build();
        reporter.report();
        reporter.close();
        System.out.println();
    }
    // TODO check http status
    assertEquals(2, cluster.getFollowers().size());
    cluster.stopAll();
    //   System.out.println(node.getNodeMetrics().getMetrics());
}
 

public static void main(final String[] args) {
    if (args.length < 7) {
        LOG.error("Args: [initialServerList], [configPath], [threads], [writeRatio], [readRatio], [valueSize] are needed.");
        System.exit(-1);
    }
    final String initialServerList = args[1];
    final String configPath = args[2];
    final int threads = Integer.parseInt(args[3]);
    final int writeRatio = Integer.parseInt(args[4]);
    final int readRatio = Integer.parseInt(args[5]);
    final int valueSize = Integer.parseInt(args[6]);

    final RheaKVStoreOptions opts = Yaml.readConfig(configPath);
    opts.setInitialServerList(initialServerList);
    final RheaKVStore rheaKVStore = new DefaultRheaKVStore();
    if (!rheaKVStore.init(opts)) {
        LOG.error("Fail to init [RheaKVStore]");
        System.exit(-1);
    }

    final List<RegionRouteTableOptions> regionRouteTableOptionsList = opts.getPlacementDriverOptions()
        .getRegionRouteTableOptionsList();

    rebalance(rheaKVStore, initialServerList, regionRouteTableOptionsList);

    rheaKVStore.bPut("benchmark", BytesUtil.writeUtf8("benchmark start at: " + new Date()));
    LOG.info(BytesUtil.readUtf8(rheaKVStore.bGet("benchmark")));

    ConsoleReporter.forRegistry(KVMetrics.metricRegistry()) //
        .build() //
        .start(30, TimeUnit.SECONDS);

    LOG.info("Start benchmark...");
    startBenchmark(rheaKVStore, threads, writeRatio, readRatio, valueSize, regionRouteTableOptionsList);
}
 

public static void main(String[] args) throws Exception {
    final MetricRegistry metrics = new MetricRegistry();

    final HadoopMetrics2Reporter metrics2Reporter = HadoopMetrics2Reporter.forRegistry(metrics).build(
            DefaultMetricsSystem.initialize("StandaloneTest"), // The application-level name
            "Test", // Component name
            "Test", // Component description
            "Test"); // Name for each metric record
    final ConsoleReporter consoleReporter = ConsoleReporter.forRegistry(metrics).build();

    MetricsSystem metrics2 = DefaultMetricsSystem.instance();
    // Writes to stdout without a filename configuration
    // Will be invoked every 10seconds by default
    FileSink sink = new FileSink();
    metrics2.register("filesink", "filesink", sink);
    sink.init(new SubsetConfiguration(null, null) {
        public String getString(String key) {
            if (key.equals("filename")) {
                return null;
            }
            return super.getString(key);
        }
    });

    // How often should the dropwizard reporter be invoked
    metrics2Reporter.start(500, TimeUnit.MILLISECONDS);
    // How often will the dropwziard metrics be logged to the console
    consoleReporter.start(2, TimeUnit.SECONDS);

    generateMetrics(metrics, 5000, 25, TimeUnit.MILLISECONDS, metrics2Reporter, 10);
}
 

public void start() {
    switch (METRICS_OPTION) {
    case "":
        logger.info("Skip streaming metricRegistry because it is empty.");
        break;
    // for test purpose
    case "console":
        logger.info("Use console to collect streaming metricRegistry.");
        ConsoleReporter consoleReporter = ConsoleReporter.forRegistry(metricRegistry)
                .convertRatesTo(TimeUnit.SECONDS).convertDurationsTo(TimeUnit.MILLISECONDS).build();
        consoleReporter.start(STREAM_METRICS_INTERVAL, TimeUnit.SECONDS);
        break;
    case "csv":
        File metricsFolder = new File("stream_metrics_csv");
        if (!metricsFolder.exists()) {
            boolean res = metricsFolder.mkdirs();
            if (!res) {
                logger.error("Cannot create dir for stream_metrics_csv");
                break;
            }
        }
        logger.info("Collect streaming metricRegistry in csv format.");
        CsvReporter scvReporter = CsvReporter.forRegistry(metricRegistry).convertRatesTo(TimeUnit.SECONDS)
                .convertDurationsTo(TimeUnit.MILLISECONDS).build(metricsFolder);
        scvReporter.start(STREAM_METRICS_INTERVAL, TimeUnit.SECONDS);
        break;
    case "jmx":
        final JmxReporter jmxReporter = JmxReporter.forRegistry(metricRegistry).build();
        jmxReporter.start();
        break;
    default:
        logger.info("Skip metricRegistry because the option {} is not identified.", METRICS_OPTION);
    }
}
 

@Bean
public ConsoleReporter consoleReporter(MetricRegistry metrics) {
    return ConsoleReporter.forRegistry(metrics)
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build();
}
 

private String getMetricReport(MetricRegistry registry) {
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    PrintStream ps = new PrintStream(outputStream);
    ConsoleReporter reporter = ConsoleReporter.forRegistry(registry)
            .outputTo(ps)
            .build();
    reporter.report();
    return new String(outputStream.toByteArray());
}
 

@Bean
@ConditionalOnProperty(prefix = "metrics.console", name = "enabled", havingValue = "true")
ScheduledReporter consoleReporter(ConsoleProperties consoleProperties, MetricRegistry metricRegistry) {
    final ScheduledReporter reporter = ConsoleReporter.forRegistry(metricRegistry).build();
    reporter.start(consoleProperties.getInterval(), TimeUnit.SECONDS);

    return reporter;
}
 

@Before
public void init() {
    MetricRegistry metricRegistry = new MetricRegistry();
    
    this.logReporter = ConsoleReporter
            .forRegistry(metricRegistry)
            .build();
    logReporter.start(1, TimeUnit.MINUTES); 
    timer = metricRegistry.timer("connection");
}
 

@Before
public void init() {
    MetricRegistry metricRegistry = new MetricRegistry();
    
    this.logReporter = ConsoleReporter
            .forRegistry(metricRegistry)
            .build();
    logReporter.start(1, TimeUnit.MINUTES); 
    timer = metricRegistry.timer("connection");
}
 

@Override
public void report(MetricRegistry metricRegistry) {
    final ConsoleReporter reporter = ConsoleReporter.forRegistry(metricRegistry)
            .convertRatesTo(TimeUnit.SECONDS)
            .convertDurationsTo(TimeUnit.MILLISECONDS)
            .build();
    reporter.start(1, TimeUnit.MINUTES);
}
 

public static Consumer<RatisMetricRegistry> consoleReporter(TimeDuration rate) {
  return ratisMetricRegistry -> {
    ConsoleReporter reporter = ConsoleReporter.forRegistry(ratisMetricRegistry.getDropWizardMetricRegistry())
        .convertRatesTo(TimeUnit.SECONDS).convertDurationsTo(TimeUnit.MILLISECONDS).build();
    reporter.start(rate.getDuration(), rate.getUnit());
    ratisMetricRegistry.setConsoleReporter(reporter);
  };
}
 

public static Consumer<RatisMetricRegistry> stopConsoleReporter() {
  return ratisMetricRegistry -> {
    ConsoleReporter reporter = ratisMetricRegistry.getConsoleReporter();
    if (reporter != null) {
      reporter.close();
    }
  };
}
 

/**
 * Add metrics reporters based on the configuration.
 */
private void addMetricsReporters() {
  if (getB("reporter.es", false)) {
    try {
      logger.info("OneOps metrics elastic search reporting is enabled!");

      esReporter = ElasticsearchReporter.forRegistry(ooMetricsRegistry).build(getSearchHost());
      esReporter.start(getI("reporter.timeout", 60), TimeUnit.SECONDS);
    } catch (IOException e) {
      logger.error("Can't start elastic search reporting.", e);
    }
  } else {
    logger.warn("OneOps metrics elastic search reporting is disabled!");
  }

  if (getB("reporter.jmx", true)) {
    logger.info("OneOps metrics JMX reporting is enabled!");
    jmxReporter = JmxReporter.forRegistry(ooMetricsRegistry).build();
    jmxReporter.start();
  } else {
    logger.warn("OneOps metrics JMX reporting is disabled!");
  }

  if (getB("reporter.console", false)) {
    consoleReporter = ConsoleReporter.forRegistry(ooMetricsRegistry).build();
    consoleReporter.start(getI("reporter.timeout", 30), TimeUnit.SECONDS);
  } else {
    logger.warn("OneOps metrics console reporting is disabled!");
  }
}
 

@Before
public void setUp(TestContext context) {
  String graphiteHost = System.getProperty("graphiteHost");

  final String registryName = "okapi";
  MetricRegistry registry = SharedMetricRegistries.getOrCreate(registryName);

  // Note the setEnabled (true or false)
  DropwizardMetricsOptions metricsOpt = new DropwizardMetricsOptions().
          setEnabled(false).setRegistryName(registryName);

  vertx = Vertx.vertx(new VertxOptions().setMetricsOptions(metricsOpt));

  reporter1 = ConsoleReporter.forRegistry(registry).build();
  reporter1.start(1, TimeUnit.SECONDS);

  if (graphiteHost != null) {
    Graphite graphite = new Graphite(new InetSocketAddress(graphiteHost, 2003));
    reporter2 = GraphiteReporter.forRegistry(registry)
            .prefixedWith("okapiserver")
            .build(graphite);
    reporter2.start(1, TimeUnit.MILLISECONDS);
  }

  DeploymentOptions opt = new DeploymentOptions()
    .setConfig(new JsonObject().put("port", Integer.toString(port)));


  vertx.deployVerticle(MainVerticle.class.getName(),
          opt, context.asyncAssertSuccess());
  httpClient = vertx.createHttpClient();
}
 

@Override
public synchronized Reporter getReporter(MetricRegistry registry) {
    if (null == reporter) {
        reporter = ConsoleReporter.forRegistry(registry)
                                  .convertRatesTo(TimeUnit.SECONDS)
                                  .convertDurationsTo(TimeUnit.MILLISECONDS)
                                  .build();
    }
    return reporter;
}
 

@Autowired
void awareMetricRegistry(MetricRegistry metricRegistry) {
    ConsoleReporter
      .forRegistry(metricRegistry)
      .build()
      .start(10, TimeUnit.SECONDS);
}
 

/**
 * Starts the metric {@code ConsoleReporter} polling every second.
 */
public MetricsSetup startConsoleReporter() {
    ConsoleReporter reporter = ConsoleReporter.forRegistry(registry()).convertRatesTo(ratesUnit)
            .convertDurationsTo(durationsUnit).build();
    reporter.start(1, TimeUnit.SECONDS);
    return this;
}
 

@Override
public ConsoleReporter get() {
    return ConsoleReporter.forRegistry(metricRegistry)
            .formattedFor(configuration.getLocale())
            .formattedFor(configuration.getTimeZone())
            .outputTo(configuration.getOutputStream())
            .convertDurationsTo(configuration.getUnitDurations())
            .convertRatesTo(configuration.getUnitRates())
            .filter(new RegexMetricFilter(configuration.getIncludeMetrics()))
            .build();
}