MeterRegistry registry = new SimpleMeterRegistry(); 
Counter counter = registry.counter("counter");
counter.increment();

CompositeMeterRegistry composite = new CompositeMeterRegistry();
 
Counter compositeCounter = composite.counter("counter");
compositeCounter.increment(); // <- 實(shí)際上這一步操作是無(wú)效的,但是不會(huì)報(bào)錯(cuò)
 
SimpleMeterRegistry simple = new SimpleMeterRegistry();
composite.add(simple);  // <- 向CompositeMeterRegistry實(shí)例中添加SimpleMeterRegistry實(shí)例
 
compositeCounter.increment();  // <-計(jì)數(shù)成功

Metrics.addRegistry(new SimpleMeterRegistry());
Counter counter = Metrics.counter("counter", "tag-1", "tag-2");
counter.increment();

MeterRegistry registry = ...
registry.timer("http.server.requests");

MeterRegistry registry = ...
registry.counter("database.calls", "db", "users")
registry.counter("http.requests", "uri", "/api/users")

MeterRegistry registry = ...
registry.counter("calls",
    "class", "database",
    "db", "users");
 
registry.counter("calls",
    "class", "http",
    "uri", "/api/users");

MeterRegistry registry = ...
registry.counter("calls",
    "class", "database",
    "db", "users");
 
registry.counter("calls",
    "class", "http",
    "uri", "/api/users");
 
 
MeterRegistry registry = ...
registry.config().commonTags("stack", "prod", "region", "us-east-1");
// 和上面的意義是一樣的
registry.config().commonTags(Arrays.asList(Tag.of("stack", "prod"), Tag.of("region", "us-east-1")));

public interface Tag extends Comparable<Tag> {
    String getKey();
 
    String getValue();
 
    static Tag of(String key, String value) {
        return new ImmutableTag(key, value);
    }
 
    default int compareTo(Tag o) {
        return this.getKey().compareTo(o.getKey());
    }
}

MeterRegistry registry = ...
registry.config()
    .meterFilter(MeterFilter.ignoreTags("http"))
    .meterFilter(MeterFilter.denyNameStartsWith("jvm"));

//實(shí)體
@Data
public class Order {
 
    private String orderId;
    private Integer amount;
    private String channel;
    private LocalDateTime createTime;
}
 
 
public class CounterMain {
 
    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");
 
    static {
            Metrics.addRegistry(new SimpleMeterRegistry());
        }
 
        public static void main(String[] args) throws Exception {
            Order order1 = new Order();
            order1.setOrderId("ORDER_ID_1");
            order1.setAmount(100);
            order1.setChannel("CHANNEL_A");
            order1.setCreateTime(LocalDateTime.now());
            createOrder(order1);
            Order order2 = new Order();
            order2.setOrderId("ORDER_ID_2");
            order2.setAmount(200);
            order2.setChannel("CHANNEL_B");
            order2.setCreateTime(LocalDateTime.now());
            createOrder(order2);
            Search.in(Metrics.globalRegistry).meters().forEach(each -> {
                StringBuilder builder = new StringBuilder();
                builder.append("name:")
                        .append(each.getId().getName())
                        .append(",tags:")
                        .append(each.getId().getTags())
                        .append(",type:").append(each.getId().getType())
                        .append(",value:").append(each.measure());
                System.out.println(builder.toString());
            });
    }
 
    private static void createOrder(Order order) {
        //忽略訂單入庫(kù)等操作
        Metrics.counter("order.create",
                "channel", order.getChannel(),
                "createTime", FORMATTER.format(order.getCreateTime())).increment();
    }
}

public class CounterBuilderMain {
 
        public static void main(String[] args) throws Exception{
            Counter counter = Counter.builder("name")  //名稱
                    .baseUnit("unit") //基礎(chǔ)單位
                    .description("desc") //描述
                    .tag("tagKey", "tagValue")  //標(biāo)簽
                    .register(new SimpleMeterRegistry());//綁定的MeterRegistry
            counter.increment();
        }
}

public class FunctionCounterMain {
 
        public static void main(String[] args) throws Exception {
            MeterRegistry registry = new SimpleMeterRegistry();
            AtomicInteger n = new AtomicInteger(0);
            //這里ToDoubleFunction匿名實(shí)現(xiàn)其實(shí)可以使用Lambda表達(dá)式簡(jiǎn)化為AtomicInteger::get
            FunctionCounter.builder("functionCounter", n, new ToDoubleFunction<AtomicInteger>() {
                @Override
                public double applyAsDouble(AtomicInteger value) {
                    return value.get();
                }
            }).baseUnit("function")
                    .description("functionCounter")
                    .tag("createOrder", "CHANNEL-A")
                    .register(registry);
            //下面模擬三次計(jì)數(shù)        
            n.incrementAndGet();
            n.incrementAndGet();
            n.incrementAndGet();
        }
}

public interface Timer extends Meter {
    ...
    void record(long var1, TimeUnit var3);
 
    default void record(Duration duration) {
        this.record(duration.toNanos(), TimeUnit.NANOSECONDS);
    }
 
    <T> T record(Supplier<T> var1);
 
    <T> T recordCallable(Callable<T> var1) throws Exception;
 
    void record(Runnable var1);
 
    default Runnable wrap(Runnable f) {
        return () -> {
            this.record(f);
        };
    }
 
    default <T> Callable<T> wrap(Callable<T> f) {
        return () -> {
            return this.recordCallable(f);
        };
    }
 
    long count();
 
    double totalTime(TimeUnit var1);
 
    default double mean(TimeUnit unit) {
        return this.count() == 0L ? 0.0D : this.totalTime(unit) / (double)this.count();
    }
 
    double max(TimeUnit var1);
    ...
}

Timer timer = ...
timer.record(() -> dontCareAboutReturnValue());
timer.recordCallable(() -> returnValue());
 
Runnable r = timer.wrap(() -> dontCareAboutReturnValue());
Callable c = timer.wrap(() -> returnValue());

public class TimerMain {
 
        private static final Random R = new Random();
 
        static {
            Metrics.addRegistry(new SimpleMeterRegistry());
        }
 
        public static void main(String[] args) throws Exception {
            Order order1 = new Order();
            order1.setOrderId("ORDER_ID_1");
            order1.setAmount(100);
            order1.setChannel("CHANNEL_A");
            order1.setCreateTime(LocalDateTime.now());
            Timer timer = Metrics.timer("timer", "createOrder", "cost");
            timer.record(() -> createOrder(order1));
        }
 
        private static void createOrder(Order order) {
            try {
                TimeUnit.SECONDS.sleep(R.nextInt(5)); //模擬方法耗時(shí)
            } catch (InterruptedException e) {
                //no-op
            }
        }
}

MeterRegistry registry = ...
Timer timer = Timer
    .builder("my.timer")
    .description("a description of what this timer does") // 可選
    .tags("region", "test") // 可選
    .register(registry);

Timer.Sample sample = Timer.start(registry);
 
// 這里做業(yè)務(wù)邏輯
Response response = ...
 
sample.stop(registry.timer("my.timer", "response", response.status()));

public interface FunctionTimer extends Meter {
    static <T> Builder<T> builder(String name, T obj, ToLongFunction<T> countFunction,
                                  ToDoubleFunction<T> totalTimeFunction,
                                  TimeUnit totalTimeFunctionUnit) {
        return new Builder<>(name, obj, countFunction, totalTimeFunction, totalTimeFunctionUnit);
    }
    ...
}

IMap<?, ?> cache = ...; // 假設(shè)使用了Hazelcast緩存
registry.more().timer("cache.gets.latency", Tags.of("name", cache.getName()), cache,
    c -> c.getLocalMapStats().getGetOperationCount(),  //實(shí)際上就是cache的一個(gè)方法，記錄緩存生命周期初始化的增量(個(gè)數(shù))
    c -> c.getLocalMapStats().getTotalGetLatency(),  // Get操作的延遲時(shí)間總量，可以理解為耗時(shí)
    TimeUnit.NANOSECONDS
);

public class FunctionTimerMain {
 
        public static void main(String[] args) throws Exception {
            //這個(gè)是為了滿足參數(shù),暫時(shí)不需要理會(huì)
            Object holder = new Object();
            AtomicLong totalTimeNanos = new AtomicLong(0);
            AtomicLong totalCount = new AtomicLong(0);
            FunctionTimer.builder("functionTimer", holder, p -> totalCount.get(), 
                    p -> totalTimeNanos.get(), TimeUnit.NANOSECONDS)
                    .register(new SimpleMeterRegistry());
            totalTimeNanos.addAndGet(10000000);
            totalCount.incrementAndGet();
        }
}

@Timed(value = "aws.scrape", longTask = true)
@Scheduled(fixedDelay = 360000)
void scrapeResources() {
    //這里做相對(duì)耗時(shí)的業(yè)務(wù)邏輯
}

public class LongTaskTimerMain {
 
        public static void main(String[] args) throws Exception{
            MeterRegistry meterRegistry = new SimpleMeterRegistry();
            LongTaskTimer longTaskTimer = meterRegistry.more().longTaskTimer("longTaskTimer");
            longTaskTimer.record(() -> {
 
                //這里編寫(xiě)Task的邏輯
            });
            //或者這樣
            Metrics.more().longTaskTimer("longTaskTimer").record(()-> {
                //這里編寫(xiě)Task的邏輯
            });
        }
} 

List<String> list = registry.gauge("listGauge", Collections.emptyList(), new ArrayList<>(), List::size); 
List<String> list2 = registry.gaugeCollectionSize("listSize2", Tags.empty(), new ArrayList<>()); 
Map<String, Integer> map = registry.gaugeMapSize("mapGauge", Tags.empty(), new HashMap<>());

AtomicInteger n = registry.gauge("numberGauge", new AtomicInteger(0));
n.set(1);
n.set(2);

//一般我們不需要操作Gauge實(shí)例
Gauge gauge = Gauge
    .builder("gauge", myObj, myObj::gaugeValue)
    .description("a description of what this gauge does") // 可選
    .tags("region", "test") // 可選
    .register(registry);

public class GaugeMain {
 
    private static final MeterRegistry MR = new SimpleMeterRegistry();
    private static final BlockingQueue<Message> QUEUE = new ArrayBlockingQueue<>(500);
    private static BlockingQueue<Message> REAL_QUEUE;
 
        static {
            REAL_QUEUE = MR.gauge("messageGauge", QUEUE, Collection::size);
        }
 
        public static void main(String[] args) throws Exception {
            consume();
            Message message = new Message();
            message.setUserId(1L);
            message.setContent("content");
            REAL_QUEUE.put(message);
        }
 
        private static void consume() throws Exception {
            new Thread(() -> {
                while (true) {
                    try {
                        Message message = REAL_QUEUE.take();
                        //handle message
                        System.out.println(message);
                    } catch (InterruptedException e) {
                        //no-op
                    }
                }
            }).start();
        }
}

public class TimeGaugeMain {
 
        private static final SimpleMeterRegistry R = new SimpleMeterRegistry();
 
        public static void main(String[] args) throws Exception{
            AtomicInteger count = new AtomicInteger();
            TimeGauge.Builder<AtomicInteger> timeGauge = TimeGauge.builder("timeGauge", count,
                    TimeUnit.SECONDS, AtomicInteger::get);
            timeGauge.register(R);
            count.addAndGet(10086);
            print();
            count.set(1);
            print();
        }
 
        private static void print()throws Exception{
            Search.in(R).meters().forEach(each -> {
                StringBuilder builder = new StringBuilder();
                builder.append("name:")
                        .append(each.getId().getName())
                        .append(",tags:")
                        .append(each.getId().getTags())
                        .append(",type:").append(each.getId().getType())
                        .append(",value:").append(each.measure());
                System.out.println(builder.toString());
            });
        }
    }
 
//輸出
name:timeGauge,tags:[],type:GAUGE,value:[Measurement{statistic='VALUE', value=10086.0}]
name:timeGauge,tags:[],type:GAUGE,value:[Measurement{statistic='VALUE', value=1.0}]

DistributionSummary summary = registry.summary("response.size");

DistributionSummary summary = DistributionSummary
    .builder("response.size")
    .description("a description of what this summary does") // 可選
    .baseUnit("bytes") // 可選
    .tags("region", "test") // 可選
    .scale(100) // 可選
    .register(registry);

public class DistributionSummaryMain {
 
        private static final DistributionSummary DS  = DistributionSummary.builder("cacheHitPercent")
                .register(new SimpleMeterRegistry());
 
        private static final LoadingCache<String, String> CACHE = CacheBuilder.newBuilder()
                .maximumSize(1000)
                .recordStats()
                .expireAfterWrite(60, TimeUnit.SECONDS)
                .build(new CacheLoader<String, String>() {
                    @Override
                    public String load(String s) throws Exception {
                        return selectFromDatabase();
                    }
                });
 
        public static void main(String[] args) throws Exception{
            String key = "doge";
            String value = CACHE.get(key);
            record();
        }
 
        private static void record()throws Exception{
            CacheStats stats = CACHE.stats();
            BigDecimal hitCount = new BigDecimal(stats.hitCount());
            BigDecimal requestCount = new BigDecimal(stats.requestCount());
            DS.record(hitCount.divide(requestCount,2,BigDecimal.ROUND_HALF_DOWN).doubleValue());
        }
}

<dependencyManagement>
      <dependencies>
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-dependencies</artifactId>
              <version>2.1.0.RELEASE</version>
              <type>pom</type>
              <scope>import</scope>
          </dependency>
      </dependencies>
  </dependencyManagement>
  <dependencies>
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-actuator</artifactId>
      </dependency>
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-aop</artifactId>
      </dependency>
      <dependency>
          <groupId>org.projectlombok</groupId>
          <artifactId>lombok</artifactId>
          <version>1.16.22</version>
      </dependency>
<dependency>
          <groupId>io.micrometer</groupId>
          <artifactId>micrometer-registry-prometheus</artifactId>
          <version>1.1.0</version>
      </dependency>
  </dependencies>

//實(shí)體
@Data
public class Message {
 
        private String orderId;
        private Long userId;
        private String content;
    }
 
    @Data
    public class Order {
 
        private String orderId;
        private Long userId;
        private Integer amount;
        private LocalDateTime createTime;
    }
 
    //控制器和服務(wù)類(lèi)
    @RestController
    public class OrderController {
 
        @Autowired
        private OrderService orderService;
 
        @PostMapping(value = "/order")
        public ResponseEntity<Boolean> createOrder(@RequestBody Order order){
            return ResponseEntity.ok(orderService.createOrder(order));
        }
    }
 
    @Slf4j
    @Service
    public class OrderService {
 
        private static final Random R = new Random();
 
        @Autowired
        private MessageService messageService;
 
        public Boolean createOrder(Order order) {
            //模擬下單
            try {
                int ms = R.nextInt(50) + 50;
                TimeUnit.MILLISECONDS.sleep(ms);
                log.info("保存訂單模擬耗時(shí){}毫秒...", ms);
            } catch (Exception e) {
                //no-op
            }
            //記錄下單總數(shù)
            Metrics.counter("order.count", "order.channel", order.getChannel()).increment();
            //發(fā)送消息
            Message message = new Message();
            message.setContent("模擬短信...");
            message.setOrderId(order.getOrderId());
            message.setUserId(order.getUserId());
            messageService.sendMessage(message);
            return true;
        }
    }
 
    @Slf4j
    @Service
    public class MessageService implements InitializingBean {
 
        private static final BlockingQueue<Message> QUEUE = new ArrayBlockingQueue<>(500);
        private static BlockingQueue<Message> REAL_QUEUE;
        private static final Executor EXECUTOR = Executors.newSingleThreadExecutor();
        private static final Random R = new Random();
 
        static {
            REAL_QUEUE = Metrics.gauge("message.gauge", Tags.of("message.gauge", "message.queue.size"), QUEUE, Collection::size);
        }
 
        public void sendMessage(Message message) {
            try {
                REAL_QUEUE.put(message);
            } catch (InterruptedException e) {
                //no-op
            }
        }
 
        @Override
        public void afterPropertiesSet() throws Exception {
            EXECUTOR.execute(() -> {
                while (true) {
                    try {
                        Message message = REAL_QUEUE.take();
                        log.info("模擬發(fā)送短信,orderId:{},userId:{},內(nèi)容:{},耗時(shí):{}毫秒", message.getOrderId(), message.getUserId(),
                                message.getContent(), R.nextInt(50));
                    } catch (Exception e) {
                        throw new IllegalStateException(e);
                    }
                }
            });
        }
    }
 
    //切面類(lèi)
    @Component
    @Aspect
    public class TimerAspect {
 
        @Around(value = "execution(* club.throwable.smp.service.*Service.*(..))")
        public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
            Signature signature = joinPoint.getSignature();
            MethodSignature methodSignature = (MethodSignature) signature;
            Method method = methodSignature.getMethod();
            Timer timer = Metrics.timer("method.cost.time", "method.name", method.getName());
            ThrowableHolder holder = new ThrowableHolder();
            Object result = timer.recordCallable(() -> {
                try {
                    return joinPoint.proceed();
                } catch (Throwable e) {
                    holder.throwable = e;
                }
                return null;
            });
            if (null != holder.throwable) {
                throw holder.throwable;
            }
            return result;
        }
 
        private class ThrowableHolder {
 
            Throwable throwable;
        }
}

server:
  port: 9091
management:
  server:
    port: 10091
  endpoints:
    web:
      exposure:
        include: '*'
      base-path: /management

management.endpoint.${端點(diǎn)ID}.enabled=true/false可以查

management.endpoints.web.exposure.include=info,health
management.endpoints.web.exposure.exclude=prometheus

wget https://github.com/prometheus/prometheus/releases/download/v2.5.0/prometheus-2.5.0.linux-amd64.tar.gz
tar xvfz prometheus-*.tar.gz
cd prometheus-*

scrape_configs:
  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
  - job_name: 'prometheus'
 
    # metrics_path defaults to '/metrics'
    # scheme defaults to 'http'.
    # 這里配置需要拉取度量信息的URL路徑，這里選擇應(yīng)用程序的prometheus端點(diǎn)
    metrics_path: /management/prometheus
    static_configs:
    # 這里配置host和port
    - targets: ['localhost:10091']

# 參數(shù) --storage.tsdb.path=存儲(chǔ)數(shù)據(jù)的路徑，默認(rèn)路徑為./data
./prometheus --config.file=prometheus.yml

wget https://s3-us-west-2.amazonaws.com/grafana-releases/release/grafana-5.3.4-1.x86_64.rpm 
sudo yum localinstall grafana-5.3.4-1.x86_64.rpm