View Javadoc

1   /**
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  
19  package org.apache.hadoop.hbase.test;
20  
21  import org.apache.hadoop.hbase.metrics.BaseSource;
22  import org.apache.hadoop.metrics2.AbstractMetric;
23  import org.apache.hadoop.metrics2.MetricsCollector;
24  import org.apache.hadoop.metrics2.MetricsInfo;
25  import org.apache.hadoop.metrics2.MetricsRecordBuilder;
26  import org.apache.hadoop.metrics2.MetricsSource;
27  import org.apache.hadoop.metrics2.MetricsTag;
28  import org.apache.hadoop.metrics2.lib.DefaultMetricsSystem;
29  
30  import java.util.HashMap;
31  import java.util.Map;
32  
33  import static org.junit.Assert.*;
34  
35  /**
36   *  A helper class that will allow tests to get into hadoop2's metrics2 values.
37   */
38  public class MetricsAssertHelperImpl implements MetricsAssertHelper {
39    private Map<String, String> tags = new HashMap<String, String>();
40    private Map<String, Number> gauges = new HashMap<String, Number>();
41    private Map<String, Long> counters = new HashMap<String, Long>();
42  
43    public class MockMetricsBuilder implements MetricsCollector {
44  
45      @Override
46      public MetricsRecordBuilder addRecord(String s) {
47        return new MockRecordBuilder(this);
48      }
49  
50      @Override
51      public MetricsRecordBuilder addRecord(MetricsInfo metricsInfo) {
52        return new MockRecordBuilder(this);
53      }
54    }
55  
56    public class MockRecordBuilder extends MetricsRecordBuilder {
57  
58      private final MetricsCollector mockMetricsBuilder;
59  
60      public MockRecordBuilder(MetricsCollector mockMetricsBuilder) {
61  
62        this.mockMetricsBuilder = mockMetricsBuilder;
63      }
64  
65      @Override
66      public MetricsRecordBuilder tag(MetricsInfo metricsInfo, String s) {
67  
68        tags.put(canonicalizeMetricName(metricsInfo.name()), s);
69        return this;
70      }
71  
72      @Override
73      public MetricsRecordBuilder add(MetricsTag metricsTag) {
74        tags.put(canonicalizeMetricName(metricsTag.name()), metricsTag.value());
75        return this;
76      }
77  
78      @Override
79      public MetricsRecordBuilder add(AbstractMetric abstractMetric) {
80        gauges.put(canonicalizeMetricName(abstractMetric.name()), abstractMetric.value());
81        return this;
82      }
83  
84      @Override
85      public MetricsRecordBuilder setContext(String s) {
86        return this;
87      }
88  
89      @Override
90      public MetricsRecordBuilder addCounter(MetricsInfo metricsInfo, int i) {
91        counters.put(canonicalizeMetricName(metricsInfo.name()), Long.valueOf(i));
92        return this;
93      }
94  
95      @Override
96      public MetricsRecordBuilder addCounter(MetricsInfo metricsInfo, long l) {
97        counters.put(canonicalizeMetricName(metricsInfo.name()), Long.valueOf(l));
98        return this;
99      }
100 
101     @Override
102     public MetricsRecordBuilder addGauge(MetricsInfo metricsInfo, int i) {
103       gauges.put(canonicalizeMetricName(metricsInfo.name()), Long.valueOf(i));
104       return this;
105     }
106 
107     @Override
108     public MetricsRecordBuilder addGauge(MetricsInfo metricsInfo, long l) {
109       gauges.put(canonicalizeMetricName(metricsInfo.name()), Long.valueOf(l));
110       return this;
111     }
112 
113     @Override
114     public MetricsRecordBuilder addGauge(MetricsInfo metricsInfo, float v) {
115       gauges.put(canonicalizeMetricName(metricsInfo.name()), Double.valueOf(v));
116       return this;
117     }
118 
119     @Override
120     public MetricsRecordBuilder addGauge(MetricsInfo metricsInfo, double v) {
121       gauges.put(canonicalizeMetricName(metricsInfo.name()), Double.valueOf(v));
122       return this;
123     }
124 
125     @Override
126     public MetricsCollector parent() {
127       return mockMetricsBuilder;
128     }
129   }
130 
131   @Override
132   public void init() {
133     // Make sure that the metrics system doesn't throw an exception when
134     // registering a source with the same name
135     DefaultMetricsSystem.setMiniClusterMode(true);
136   }
137 
138   @Override
139   public void assertTag(String name, String expected, BaseSource source) {
140     getMetrics(source);
141     String cName = canonicalizeMetricName(name);
142     assertEquals("Tags should be equal", expected, tags.get(cName));
143   }
144 
145   @Override
146   public void assertGauge(String name, long expected, BaseSource source) {
147     long found = getGaugeLong(name, source);
148     assertEquals("Metrics Should be equal", (long) Long.valueOf(expected), found);
149   }
150 
151   @Override
152   public void assertGaugeGt(String name, long expected, BaseSource source) {
153     double found = getGaugeDouble(name, source);
154     assertTrue(name + " (" + found + ") should be greater than " + expected, found > expected);
155   }
156 
157   @Override
158   public void assertGaugeLt(String name, long expected, BaseSource source) {
159     double found = getGaugeDouble(name, source);
160     assertTrue(name + "(" + found + ") should be less than " + expected, found < expected);
161   }
162 
163   @Override
164   public void assertGauge(String name, double expected, BaseSource source) {
165     double found = getGaugeDouble(name, source);
166     assertEquals("Metrics Should be equal", (double) Double.valueOf(expected), found, 0.01);
167   }
168 
169   @Override
170   public void assertGaugeGt(String name, double expected, BaseSource source) {
171     double found = getGaugeDouble(name, source);
172     assertTrue(name + "(" + found + ") should be greater than " + expected, found > expected);
173   }
174 
175   @Override
176   public void assertGaugeLt(String name, double expected, BaseSource source) {
177     double found = getGaugeDouble(name, source);
178     assertTrue(name + "(" + found + ") should be less than " + expected, found < expected);
179   }
180 
181   @Override
182   public void assertCounter(String name, long expected, BaseSource source) {
183     long found = getCounter(name, source);
184     assertEquals("Metrics Counters should be equal", (long) Long.valueOf(expected), found);
185   }
186 
187   @Override
188   public void assertCounterGt(String name, long expected, BaseSource source) {
189     long found = getCounter(name, source);
190     assertTrue(name + " (" + found + ") should be greater than " + expected, found > expected);
191   }
192 
193   @Override
194   public void assertCounterLt(String name, long expected, BaseSource source) {
195     long found = getCounter(name, source);
196     assertTrue(name + "(" + found + ") should be less than " + expected, found < expected);
197   }
198 
199   @Override
200   public long getCounter(String name, BaseSource source) {
201     getMetrics(source);
202     String cName = canonicalizeMetricName(name);
203     assertNotNull("Should get counter "+cName + " but did not",counters.get(cName));
204     return  counters.get(cName).longValue();
205   }
206 
207   @Override
208   public boolean checkCounterExists(String name, BaseSource source) {
209     getMetrics(source);
210     String cName = canonicalizeMetricName(name);
211     return (counters.get(cName) != null) ? true : false;
212   }
213   
214   @Override
215   public double getGaugeDouble(String name, BaseSource source) {
216     getMetrics(source);
217     String cName = canonicalizeMetricName(name);
218     assertNotNull("Should get gauge "+cName + " but did not",gauges.get(cName));
219     return  gauges.get(cName).doubleValue();
220   }
221 
222   @Override
223   public long getGaugeLong(String name, BaseSource source) {
224     getMetrics(source);
225     String cName = canonicalizeMetricName(name);
226     assertNotNull("Should get gauge " + cName + " but did not", gauges.get(cName));
227     return gauges.get(cName).longValue();
228   }
229 
230   @Override
231   public String toDebugString(BaseSource source) {
232     getMetrics(source);
233     StringBuilder sb = new StringBuilder();
234     sb.append("Tags=").append(tags).append(", Counters=").append(counters);
235     return sb.append(", Gauges=").append(gauges).toString();
236   }
237 
238   private void reset() {
239     tags.clear();
240     gauges.clear();
241     counters.clear();
242   }
243 
244   private void getMetrics(BaseSource source) {
245     reset();
246     if (!(source instanceof MetricsSource)) {
247       assertTrue("The Source passed must be a MetricsSource", false);
248     }
249     MetricsSource impl = (MetricsSource) source;
250 
251     impl.getMetrics(new MockMetricsBuilder(), true);
252 
253   }
254 
255   private String canonicalizeMetricName(String in) {
256     return in.toLowerCase().replaceAll("[^A-Za-z0-9 ]", "");
257   }
258 }