diff --git oak-core/pom.xml oak-core/pom.xml index 37cf2d2..66d41fe 100644 --- oak-core/pom.xml +++ oak-core/pom.xml @@ -214,6 +214,12 @@ 2.4 + io.dropwizard.metrics + metrics-core + 3.1.0 + true + + org.apache.jackrabbit jackrabbit-aws-ext ${jackrabbit.version} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/CompositeStats.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/CompositeStats.java new file mode 100644 index 0000000..a62df36 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/CompositeStats.java @@ -0,0 +1,94 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.plugins.metric; + +import java.util.concurrent.TimeUnit; + +import org.apache.jackrabbit.oak.stats.SimpleStats; +import org.apache.jackrabbit.oak.stats.CounterStats; +import org.apache.jackrabbit.oak.stats.MeterStats; +import org.apache.jackrabbit.oak.stats.TimerStats; + +/** + * Stats instances which delegates to both TimeSeries based counter + * and Metrics based meters so as to allow both systems to collect + * stats + */ +class CompositeStats implements CounterStats, MeterStats, TimerStats { + private final SimpleStats delegate; + private final MetricCounterStats counter; + private final MetricTimerStats timer; + private final MetricMeterStats meter; + + public CompositeStats(SimpleStats delegate, MetricCounterStats counter){ + this(delegate, counter, null, null); + } + + public CompositeStats(SimpleStats delegate, MetricTimerStats timer){ + this(delegate, null, timer, null); + } + + public CompositeStats(SimpleStats delegate, MetricMeterStats meter){ + this(delegate, null, null, meter); + } + + private CompositeStats(SimpleStats delegate, MetricCounterStats counter, + MetricTimerStats timer, MetricMeterStats meter) { + this.delegate = delegate; + this.counter = counter; + this.timer = timer; + this.meter = meter; + } + + @Override + public long getCount() { + return delegate.getCount(); + } + + @Override + public void inc() { + delegate.inc(); + counter.inc(); + } + + @Override + public void dec() { + delegate.dec(); + counter.dec(); + } + + @Override + public void mark() { + delegate.mark(); + meter.mark(); + } + + @Override + public void mark(long n) { + delegate.mark(n); + meter.mark(n); + } + + @Override + public void update(long duration, TimeUnit unit) { + delegate.update(duration, unit); + timer.update(duration, unit); + } +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/MetricCounterStats.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/MetricCounterStats.java new file mode 100644 index 0000000..a89350f --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/MetricCounterStats.java @@ -0,0 +1,50 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.plugins.metric; + +import com.codahale.metrics.Counter; +import org.apache.jackrabbit.oak.stats.CounterStats; + +class MetricCounterStats implements CounterStats { + private final Counter counter; + + public MetricCounterStats(Counter counter) { + this.counter = counter; + } + + @Override + public long getCount() { + return counter.getCount(); + } + + @Override + public void inc() { + counter.inc(); + } + + @Override + public void dec() { + counter.dec(); + } + + public Counter getCounter() { + return counter; + } +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/MetricMeterStats.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/MetricMeterStats.java new file mode 100644 index 0000000..13cbb9e --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/MetricMeterStats.java @@ -0,0 +1,41 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.plugins.metric; + +import com.codahale.metrics.Meter; +import org.apache.jackrabbit.oak.stats.MeterStats; + +class MetricMeterStats implements MeterStats { + private final Meter meter; + + public MetricMeterStats(Meter meter) { + this.meter = meter; + } + + @Override + public void mark() { + meter.mark(); + } + + @Override + public void mark(long n) { + meter.mark(n); + } +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/MetricStatisticsProvider.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/MetricStatisticsProvider.java new file mode 100644 index 0000000..d298432 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/MetricStatisticsProvider.java @@ -0,0 +1,241 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.plugins.metric; + +import java.util.Hashtable; +import java.util.Map; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; + +import javax.management.MBeanServer; +import javax.management.MalformedObjectNameException; +import javax.management.ObjectName; + +import com.codahale.metrics.JmxReporter; +import com.codahale.metrics.Meter; +import com.codahale.metrics.MetricRegistry; +import com.codahale.metrics.ObjectNameFactory; +import com.codahale.metrics.RatioGauge; +import com.codahale.metrics.Timer; +import com.google.common.collect.Maps; +import org.apache.felix.scr.annotations.Activate; +import org.apache.felix.scr.annotations.Component; +import org.apache.felix.scr.annotations.ConfigurationPolicy; +import org.apache.felix.scr.annotations.Deactivate; +import org.apache.felix.scr.annotations.Property; +import org.apache.felix.scr.annotations.Reference; +import org.apache.jackrabbit.api.stats.RepositoryStatistics; +import org.apache.jackrabbit.api.stats.RepositoryStatistics.Type; +import org.apache.jackrabbit.oak.commons.PropertiesUtil; +import org.apache.jackrabbit.oak.spi.whiteboard.WhiteboardUtils; +import org.apache.jackrabbit.oak.stats.SimpleStats; +import org.apache.jackrabbit.oak.stats.StatisticsProvider; +import org.apache.jackrabbit.oak.stats.CounterStats; +import org.apache.jackrabbit.oak.stats.MeterStats; +import org.apache.jackrabbit.oak.stats.TimerStats; +import org.apache.jackrabbit.stats.RepositoryStatisticsImpl; +import org.osgi.framework.BundleContext; +import org.osgi.framework.ServiceRegistration; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@Component(policy = ConfigurationPolicy.REQUIRE, + metatype = true, + label = "Apache Jackrabbit Oak Metrics Statistics Provider", + description = "Repository statistics provider based on Metrics library. " + + "See http://metrics.dropwizard.io") +public class MetricStatisticsProvider implements StatisticsProvider { + private static final Logger log = LoggerFactory.getLogger(MetricStatisticsProvider.class); + + private static final boolean PROP_DISABLED_DEFAULT = false; + + @Property( + boolValue = PROP_DISABLED_DEFAULT, + label = "Disable this component", + description = "If true, this component is disabled." + ) + private static final String PROP_DISABLED = "disabled"; + + private static final String JMX_TYPE = "Metrics"; + + private final Map statsRegistry = Maps.newHashMap(); + private MetricRegistry registry; + private JmxReporter reporter; + private ScheduledExecutorService executor; + private RepositoryStatisticsImpl repoStats; + private ServiceRegistration reg; + + @Reference + private MBeanServer server; + + @Activate + private void activate(BundleContext context, Map config) { + boolean disabled = PropertiesUtil.toBoolean(config.get(PROP_DISABLED), PROP_DISABLED_DEFAULT); + + if (disabled) { + log.info("Component disabled by configuration"); + return; + } + + registry = new MetricRegistry(); + executor = Executors.newSingleThreadScheduledExecutor(); + repoStats = new RepositoryStatisticsImpl(executor); + reporter = JmxReporter.forRegistry(registry) + .inDomain(WhiteboardUtils.JMX_OAK_DOMAIN) + .registerWith(server) + .createsObjectNamesWith(new OakNameFactory()) + .build(); + reporter.start(); + + registerAverages(); + reg = context.registerService(StatisticsProvider.class.getName(), this, null); + } + + @Deactivate + private void deactivate() { + if (reg != null){ + reg.unregister(); + reg = null; + } + + //TODO Refactor ExecutorCloser in Oak as a utility class and + //use that here + if (executor != null) { + executor.shutdown(); + } + + if (reporter != null){ + reporter.close(); + } + } + + @Override + public RepositoryStatistics getStats() { + return repoStats; + } + + @Override + public MeterStats getMeter(String name) { + return getStats(name, StatsType.METER); + } + + @Override + public CounterStats getStatsCounter(String name) { + return getStats(name, StatsType.COUNTER); + } + + @Override + public TimerStats getTimer(String name) { + return getStats(name, StatsType.TIMER); + } + + private synchronized CompositeStats getStats(String type, StatsType statsType) { + String name = type; + Type enumType = Type.valueOf(type); + CompositeStats stats = statsRegistry.get(type); + if (stats == null) { + SimpleStats delegate; + if (enumType != null) { + delegate = new SimpleStats(repoStats.getCounter(enumType)); + name = typeToName(enumType); + } else { + //TODO Need to look into this aspect. Type being an enum + //cannot be enhanced so have to use String but then we need + //some config to map unknown type and reset flag value for them + delegate = new SimpleStats(repoStats.getCounter(type, false)); + } + stats = createStat(name, statsType, delegate); + statsRegistry.put(type, stats); + } + return stats; + } + + private CompositeStats createStat(String name, StatsType statsType, SimpleStats delegate) { + switch (statsType) { + case COUNTER: + MetricCounterStats counter = new MetricCounterStats(registry.counter(name)); + return new CompositeStats(delegate, counter); + case TIMER: + MetricTimerStats timer = new MetricTimerStats(registry.timer(name)); + return new CompositeStats(delegate, timer); + case METER: + MetricMeterStats meter = new MetricMeterStats(registry.meter(name)); + return new CompositeStats(delegate, meter); + } + throw new IllegalStateException(); + } + + private void registerAverages() { + registry.register(typeToName(Type.SESSION_READ_AVERAGE), + new AvgGauge(registry.meter(typeToName(Type.SESSION_READ_COUNTER)), + registry.timer(typeToName(Type.SESSION_READ_DURATION)))); + + registry.register(typeToName(Type.SESSION_WRITE_AVERAGE), + new AvgGauge(registry.meter(typeToName(Type.SESSION_WRITE_COUNTER)), + registry.timer(typeToName(Type.SESSION_WRITE_DURATION)))); + + registry.register(typeToName(Type.QUERY_AVERAGE), + new AvgGauge(registry.meter(typeToName(Type.QUERY_COUNT)), + registry.timer(typeToName(Type.QUERY_DURATION)))); + + registry.register(typeToName(Type.OBSERVATION_EVENT_AVERAGE), + new AvgGauge(registry.meter(typeToName(Type.OBSERVATION_EVENT_COUNTER)), + registry.timer(typeToName(Type.OBSERVATION_EVENT_DURATION)))); + } + + private static String typeToName(Type type){ + return type.name(); + } + + private enum StatsType {METER, COUNTER, TIMER} + + private static class AvgGauge extends RatioGauge { + private final Meter meter; + private final Timer timer; + + private AvgGauge(Meter meter, Timer timer) { + this.meter = meter; + this.timer = timer; + } + + @Override + protected Ratio getRatio() { + //TODO Should we use getMeanRate + return Ratio.of(meter.getFifteenMinuteRate(), + timer.getFifteenMinuteRate()); + } + } + + private static class OakNameFactory implements ObjectNameFactory { + @Override + public ObjectName createName(String type, String domain, String name) { + Hashtable table = new Hashtable(); + table.put("type", JMX_TYPE); + table.put("name", name); + try { + return new ObjectName(domain, table); + } catch (MalformedObjectNameException e) { + log.warn("Unable to register {} {}", type, name, e); + throw new RuntimeException(e); + } + } + } + +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/MetricTimerStats.java oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/MetricTimerStats.java new file mode 100644 index 0000000..8b58d3a --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/metric/MetricTimerStats.java @@ -0,0 +1,38 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.plugins.metric; + +import java.util.concurrent.TimeUnit; + +import com.codahale.metrics.Timer; +import org.apache.jackrabbit.oak.stats.TimerStats; + +class MetricTimerStats implements TimerStats { + private final Timer timer; + + public MetricTimerStats(Timer timer) { + this.timer = timer; + } + + @Override + public void update(long duration, TimeUnit unit) { + timer.update(duration, unit); + } +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/spi/whiteboard/WhiteboardUtils.java oak-core/src/main/java/org/apache/jackrabbit/oak/spi/whiteboard/WhiteboardUtils.java index dcc625c..9588392 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/spi/whiteboard/WhiteboardUtils.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/spi/whiteboard/WhiteboardUtils.java @@ -39,6 +39,11 @@ import com.google.common.collect.Iterables; public class WhiteboardUtils { + /** + * JMX Domain name under which Oak related JMX MBeans are registered + */ + public static final String JMX_OAK_DOMAIN = "org.apache.jackrabbit.oak"; + public static Registration scheduleWithFixedDelay( Whiteboard whiteboard, Runnable runnable, long delayInSeconds) { return scheduleWithFixedDelay(whiteboard, runnable, delayInSeconds, false); @@ -73,7 +78,7 @@ public class WhiteboardUtils { table.put("name", quoteIfRequired(name)); return whiteboard.register(iface, bean, ImmutableMap.of( "jmx.objectname", - new ObjectName("org.apache.jackrabbit.oak", table))); + new ObjectName(JMX_OAK_DOMAIN, table))); } catch (MalformedObjectNameException e) { throw new IllegalArgumentException(e); } diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/stats/CounterStats.java oak-core/src/main/java/org/apache/jackrabbit/oak/stats/CounterStats.java new file mode 100644 index 0000000..b069a07 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/stats/CounterStats.java @@ -0,0 +1,39 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.stats; + +public interface CounterStats { + /** + * Returns the counter's current value. + * + * @return the counter's current value + */ + long getCount(); + + /** + * Increment the counter by one. + */ + void inc(); + + /** + * Decrement the counter by one. + */ + void dec(); +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/stats/DefaultStatisticsProvider.java oak-core/src/main/java/org/apache/jackrabbit/oak/stats/DefaultStatisticsProvider.java new file mode 100644 index 0000000..7e77f40 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/stats/DefaultStatisticsProvider.java @@ -0,0 +1,74 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.stats; + +import java.util.Map; +import java.util.concurrent.ScheduledExecutorService; + +import com.google.common.collect.Maps; +import org.apache.jackrabbit.api.stats.RepositoryStatistics; +import org.apache.jackrabbit.api.stats.RepositoryStatistics.Type; +import org.apache.jackrabbit.stats.RepositoryStatisticsImpl; + +public final class DefaultStatisticsProvider implements StatisticsProvider { + private final RepositoryStatisticsImpl repoStats; + private final Map statsMeters = Maps.newHashMap(); + + public DefaultStatisticsProvider(ScheduledExecutorService executor){ + this.repoStats = new RepositoryStatisticsImpl(executor); + } + + @Override + public RepositoryStatistics getStats() { + return repoStats; + } + + @Override + public MeterStats getMeter(String name) { + return getStats(name); + } + + @Override + public CounterStats getStatsCounter(String name) { + return getStats(name); + } + + @Override + public TimerStats getTimer(String name) { + return getStats(name); + } + + private synchronized SimpleStats getStats(String type){ + Type enumType = Type.valueOf(type); + SimpleStats stats = statsMeters.get(type); + if (stats == null){ + if (enumType != null) { + stats = new SimpleStats(repoStats.getCounter(enumType)); + } else { + //TODO Need to look into this aspect. Type being an enum + //cannot be enhanced so have to use String but then we need + //some config to map unknown type and reset flag value for them + stats = new SimpleStats(repoStats.getCounter(type, false)); + } + statsMeters.put(type, stats); + } + return stats; + } +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/stats/MeterStats.java oak-core/src/main/java/org/apache/jackrabbit/oak/stats/MeterStats.java new file mode 100644 index 0000000..3fc44d7 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/stats/MeterStats.java @@ -0,0 +1,34 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.stats; + +public interface MeterStats { + /** + * Mark the occurrence of an event. + */ + void mark(); + + /** + * Mark the occurrence of a given number of events. + * + * @param n the number of events + */ + void mark(long n); +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/stats/NoopStats.java oak-core/src/main/java/org/apache/jackrabbit/oak/stats/NoopStats.java new file mode 100644 index 0000000..6d8ddff --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/stats/NoopStats.java @@ -0,0 +1,61 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.stats; + +import java.util.concurrent.TimeUnit; + +final class NoopStats implements TimerStats, MeterStats, CounterStats { + + public static final NoopStats INSTANCE = new NoopStats(); + + private NoopStats(){ + + } + + @Override + public long getCount() { + return 0; + } + + @Override + public void inc() { + + } + + @Override + public void dec() { + + } + + @Override + public void mark() { + + } + + @Override + public void mark(long n) { + + } + + @Override + public void update(long duration, TimeUnit unit) { + + } +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/stats/SimpleStats.java oak-core/src/main/java/org/apache/jackrabbit/oak/stats/SimpleStats.java new file mode 100644 index 0000000..77fb031 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/stats/SimpleStats.java @@ -0,0 +1,61 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.stats; + +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicLong; + +public final class SimpleStats implements TimerStats, MeterStats, CounterStats { + private final AtomicLong statsHolder; + + public SimpleStats(AtomicLong statsHolder) { + this.statsHolder = statsHolder; + } + + @Override + public long getCount() { + return statsHolder.get(); + } + + @Override + public void inc() { + statsHolder.getAndIncrement(); + } + + @Override + public void dec() { + statsHolder.getAndDecrement(); + } + + @Override + public void mark() { + inc(); + } + + @Override + public void mark(long n) { + statsHolder.getAndAdd(n); + } + + @Override + public void update(long duration, TimeUnit unit) { + statsHolder.getAndAdd(duration); + } +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/stats/StatisticManager.java oak-core/src/main/java/org/apache/jackrabbit/oak/stats/StatisticManager.java index 108690b..6b81d89 100644 --- oak-core/src/main/java/org/apache/jackrabbit/oak/stats/StatisticManager.java +++ oak-core/src/main/java/org/apache/jackrabbit/oak/stats/StatisticManager.java @@ -30,8 +30,8 @@ import org.apache.jackrabbit.api.stats.RepositoryStatistics.Type; import org.apache.jackrabbit.oak.api.jmx.RepositoryStatsMBean; import org.apache.jackrabbit.oak.spi.whiteboard.CompositeRegistration; import org.apache.jackrabbit.oak.spi.whiteboard.Whiteboard; +import org.apache.jackrabbit.oak.spi.whiteboard.WhiteboardUtils; import org.apache.jackrabbit.stats.QueryStatImpl; -import org.apache.jackrabbit.stats.RepositoryStatisticsImpl; import org.apache.jackrabbit.stats.TimeSeriesMax; import org.apache.jackrabbit.stats.jmx.QueryStatManager; @@ -42,7 +42,7 @@ import org.apache.jackrabbit.stats.jmx.QueryStatManager; */ public class StatisticManager { private final QueryStatImpl queryStat = new QueryStatImpl(); - private final RepositoryStatisticsImpl repoStats; + private final StatisticsProvider repoStats; private final TimeSeriesMax maxQueueLength; private final CompositeRegistration registration; @@ -53,12 +53,12 @@ public class StatisticManager { */ public StatisticManager(Whiteboard whiteboard, ScheduledExecutorService executor) { queryStat.setEnabled(true); - repoStats = new RepositoryStatisticsImpl(executor); + repoStats = getStatsProvider(whiteboard, executor); maxQueueLength = new TimeSeriesMax(-1); registration = new CompositeRegistration( registerMBean(whiteboard, QueryStatManagerMBean.class, new QueryStatManager(queryStat), "QueryStat", "Oak Query Statistics"), - registerMBean(whiteboard, RepositoryStatsMBean.class, new RepositoryStats(repoStats, maxQueueLength), + registerMBean(whiteboard, RepositoryStatsMBean.class, new RepositoryStats(repoStats.getStats(), maxQueueLength), RepositoryStats.TYPE, "Oak Repository Statistics"), scheduleWithFixedDelay(whiteboard, new Runnable() { @Override @@ -86,9 +86,22 @@ public class StatisticManager { * @see org.apache.jackrabbit.stats.RepositoryStatisticsImpl#getCounter(org.apache.jackrabbit.api.stats.RepositoryStatistics.Type) */ public AtomicLong getCounter(Type type) { - return repoStats.getCounter(type); + throw new UnsupportedOperationException(); } + public MeterStats getMeter(Type type){ + return repoStats.getMeter(type.name()); + } + + public CounterStats getStatsCounter(Type type){ + return repoStats.getStatsCounter(type.name()); + } + + public TimerStats getTimer(Type type){ + return repoStats.getTimer(type.name()); + } + + public TimeSeriesMax maxQueLengthRecorder() { return maxQueueLength; } @@ -101,4 +114,13 @@ public class StatisticManager { registration.unregister(); } + private StatisticsProvider getStatsProvider(Whiteboard wb, + ScheduledExecutorService executor) { + StatisticsProvider provider = WhiteboardUtils.getService(wb, StatisticsProvider.class); + if (provider == null){ + provider = new DefaultStatisticsProvider(executor); + } + return provider; + } + } diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/stats/StatisticsProvider.java oak-core/src/main/java/org/apache/jackrabbit/oak/stats/StatisticsProvider.java new file mode 100644 index 0000000..de8a2ca --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/stats/StatisticsProvider.java @@ -0,0 +1,56 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.stats; + +import org.apache.jackrabbit.api.stats.RepositoryStatistics; + +public interface StatisticsProvider { + + StatisticsProvider NOOP = new StatisticsProvider() { + @Override + public RepositoryStatistics getStats() { + return null; + } + + @Override + public MeterStats getMeter(String name) { + return NoopStats.INSTANCE; + } + + @Override + public CounterStats getStatsCounter(String name) { + return NoopStats.INSTANCE; + } + + @Override + public TimerStats getTimer(String name) { + return NoopStats.INSTANCE; + } + }; + + + RepositoryStatistics getStats(); + + MeterStats getMeter(String name); + + CounterStats getStatsCounter(String name); + + TimerStats getTimer(String name); +} diff --git oak-core/src/main/java/org/apache/jackrabbit/oak/stats/TimerStats.java oak-core/src/main/java/org/apache/jackrabbit/oak/stats/TimerStats.java new file mode 100644 index 0000000..dba6480 --- /dev/null +++ oak-core/src/main/java/org/apache/jackrabbit/oak/stats/TimerStats.java @@ -0,0 +1,32 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.jackrabbit.oak.stats; + +import java.util.concurrent.TimeUnit; + +public interface TimerStats { + /** + * Adds a recorded duration. + * + * @param duration the length of the duration + * @param unit the scale unit of {@code duration} + */ + void update(long duration, TimeUnit unit); +} diff --git oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/delegate/SessionDelegate.java oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/delegate/SessionDelegate.java index 73e42df..e6e337c 100644 --- oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/delegate/SessionDelegate.java +++ oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/delegate/SessionDelegate.java @@ -29,7 +29,6 @@ import static org.apache.jackrabbit.oak.commons.PathUtils.denotesRoot; import java.io.IOException; import java.util.Iterator; import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; @@ -64,6 +63,8 @@ import org.apache.jackrabbit.oak.spi.security.authorization.AuthorizationConfigu import org.apache.jackrabbit.oak.spi.security.authorization.permission.PermissionProvider; import org.apache.jackrabbit.oak.stats.Clock; import org.apache.jackrabbit.oak.stats.StatisticManager; +import org.apache.jackrabbit.oak.stats.MeterStats; +import org.apache.jackrabbit.oak.stats.TimerStats; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -92,10 +93,10 @@ public class SessionDelegate { private final Counters sessionCounters; // repository-wide counters for statistics about all sessions - private final AtomicLong readCounter; - private final AtomicLong readDuration; - private final AtomicLong writeCounter; - private final AtomicLong writeDuration; + private final MeterStats readCounter; + private final TimerStats readDuration; + private final MeterStats writeCounter; + private final TimerStats writeDuration; private boolean isAlive = true; private int sessionOpCount; @@ -149,10 +150,10 @@ public class SessionDelegate { this.sessionStats = new SessionStats(contentSession.toString(), contentSession.getAuthInfo(), clock, refreshStrategy, this, statisticManager); this.sessionCounters = sessionStats.getCounters(); - readCounter = statisticManager.getCounter(SESSION_READ_COUNTER); - readDuration = statisticManager.getCounter(SESSION_READ_DURATION); - writeCounter = statisticManager.getCounter(SESSION_WRITE_COUNTER); - writeDuration = statisticManager.getCounter(SESSION_WRITE_DURATION); + readCounter = statisticManager.getMeter(SESSION_READ_COUNTER); + readDuration = statisticManager.getTimer(SESSION_READ_DURATION); + writeCounter = statisticManager.getMeter(SESSION_WRITE_COUNTER); + writeDuration = statisticManager.getTimer(SESSION_WRITE_DURATION); } @Nonnull @@ -622,14 +623,14 @@ public class SessionDelegate { if (op.isUpdate()) { sessionCounters.writeTime = t0; sessionCounters.writeCount++; - writeCounter.incrementAndGet(); - writeDuration.addAndGet(dt); + writeCounter.mark(); + writeDuration.update(dt, TimeUnit.MILLISECONDS); updateCount++; } else { sessionCounters.readTime = t0; sessionCounters.readCount++; - readCounter.incrementAndGet(); - readDuration.addAndGet(dt); + readCounter.mark(); + readDuration.update(dt, TimeUnit.MILLISECONDS); } if (op.isSave()) { refreshAtNextAccess.refreshAtNextAccess(false); diff --git oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/observation/ChangeProcessor.java oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/observation/ChangeProcessor.java index 0801d72..2cc9d39 100644 --- oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/observation/ChangeProcessor.java +++ oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/observation/ChangeProcessor.java @@ -29,7 +29,6 @@ import static org.apache.jackrabbit.oak.spi.whiteboard.WhiteboardUtils.scheduleW import java.util.Map; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; -import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicReference; import javax.annotation.Nonnull; @@ -60,6 +59,8 @@ import org.apache.jackrabbit.oak.spi.whiteboard.Registration; import org.apache.jackrabbit.oak.spi.whiteboard.Whiteboard; import org.apache.jackrabbit.oak.spi.whiteboard.WhiteboardExecutor; import org.apache.jackrabbit.oak.stats.StatisticManager; +import org.apache.jackrabbit.oak.stats.MeterStats; +import org.apache.jackrabbit.oak.stats.TimerStats; import org.apache.jackrabbit.oak.util.PerfLogger; import org.apache.jackrabbit.stats.TimeSeriesMax; import org.slf4j.Logger; @@ -102,8 +103,8 @@ class ChangeProcessor implements Observer { private final ListenerTracker tracker; private final EventListener eventListener; private final AtomicReference filterProvider; - private final AtomicLong eventCount; - private final AtomicLong eventDuration; + private final MeterStats eventCount; + private final TimerStats eventDuration; private final TimeSeriesMax maxQueueLength; private final int queueLength; private final CommitRateLimiter commitRateLimiter; @@ -133,8 +134,8 @@ class ChangeProcessor implements Observer { this.tracker = tracker; eventListener = tracker.getTrackedListener(); filterProvider = new AtomicReference(filter); - this.eventCount = statisticManager.getCounter(OBSERVATION_EVENT_COUNTER); - this.eventDuration = statisticManager.getCounter(OBSERVATION_EVENT_DURATION); + this.eventCount = statisticManager.getMeter(OBSERVATION_EVENT_COUNTER); + this.eventDuration = statisticManager.getTimer(OBSERVATION_EVENT_DURATION); this.maxQueueLength = statisticManager.maxQueLengthRecorder(); this.queueLength = queueLength; this.commitRateLimiter = commitRateLimiter; @@ -340,10 +341,10 @@ class ChangeProcessor implements Observer { this.events = events; } - public void updateCounters(AtomicLong eventCount, AtomicLong eventDuration) { + public void updateCounters(MeterStats eventCount, TimerStats eventDuration) { checkState(this.eventCount >= 0); - eventCount.addAndGet(this.eventCount); - eventDuration.addAndGet(System.nanoTime() - t0 - sysTime); + eventCount.mark(this.eventCount); + eventDuration.update(System.nanoTime() - t0 - sysTime, TimeUnit.NANOSECONDS); this.eventCount = -1; } diff --git oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/query/QueryManagerImpl.java oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/query/QueryManagerImpl.java index 01f4409..4feb461 100644 --- oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/query/QueryManagerImpl.java +++ oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/query/QueryManagerImpl.java @@ -28,7 +28,7 @@ import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Map.Entry; -import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.TimeUnit; import javax.jcr.Node; import javax.jcr.RepositoryException; @@ -48,6 +48,8 @@ import org.apache.jackrabbit.oak.jcr.query.qom.QueryObjectModelFactoryImpl; import org.apache.jackrabbit.oak.jcr.session.SessionContext; import org.apache.jackrabbit.oak.plugins.memory.PropertyStates; import org.apache.jackrabbit.oak.spi.query.PropertyValues; +import org.apache.jackrabbit.oak.stats.MeterStats; +import org.apache.jackrabbit.oak.stats.TimerStats; /** * The implementation of the corresponding JCR interface. @@ -59,8 +61,8 @@ public class QueryManagerImpl implements QueryManager { private final QueryObjectModelFactoryImpl qomFactory; private final QueryEngine queryEngine; private final HashSet supportedQueryLanguages = new HashSet(); - private final AtomicLong queryCount; - private final AtomicLong queryDuration; + private final MeterStats queryCount; + private final TimerStats queryDuration; public QueryManagerImpl(SessionContext sessionContext) { this.sessionDelegate = sessionContext.getSessionDelegate(); @@ -68,8 +70,8 @@ public class QueryManagerImpl implements QueryManager { qomFactory = new QueryObjectModelFactoryImpl(this, sessionContext); queryEngine = sessionDelegate.getQueryEngine(); supportedQueryLanguages.addAll(queryEngine.getSupportedQueryLanguages()); - queryCount = sessionContext.getCounter(QUERY_COUNT); - queryDuration = sessionContext.getCounter(QUERY_DURATION); + queryCount = sessionContext.getMeter(QUERY_COUNT); + queryDuration = sessionContext.getTimer(QUERY_DURATION); } @Override @@ -132,9 +134,9 @@ public class QueryManagerImpl implements QueryManager { Result r = queryEngine.executeQuery( statement, language, limit, offset, bindMap, sessionContext.getSessionLocalMappings()); - queryCount.incrementAndGet(); + queryCount.mark(); long dt = (System.nanoTime() - t0) / 1000000; - queryDuration.addAndGet(dt); + queryDuration.update(dt, TimeUnit.MILLISECONDS); sessionContext.getStatisticManager() .logQueryEvaluationTime(language, statement, dt); return new QueryResultImpl(sessionContext, r); diff --git oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/session/SessionContext.java oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/session/SessionContext.java index 197ff40..9aba4bc 100644 --- oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/session/SessionContext.java +++ oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/session/SessionContext.java @@ -25,7 +25,6 @@ import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; -import java.util.concurrent.atomic.AtomicLong; import javax.annotation.CheckForNull; import javax.annotation.Nonnull; @@ -66,6 +65,9 @@ import org.apache.jackrabbit.oak.spi.security.user.UserConfiguration; import org.apache.jackrabbit.oak.spi.whiteboard.Whiteboard; import org.apache.jackrabbit.oak.spi.xml.ProtectedItemImporter; import org.apache.jackrabbit.oak.stats.StatisticManager; +import org.apache.jackrabbit.oak.stats.CounterStats; +import org.apache.jackrabbit.oak.stats.MeterStats; +import org.apache.jackrabbit.oak.stats.TimerStats; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -189,8 +191,18 @@ public class SessionContext implements NamePathMapper { } @Nonnull - public AtomicLong getCounter(Type type) { - return statisticManager.getCounter(type); + public MeterStats getMeter(Type type){ + return statisticManager.getMeter(type); + } + + @Nonnull + public TimerStats getTimer(Type type) { + return statisticManager.getTimer(type); + } + + @Nonnull + public CounterStats getCount(Type type) { + return statisticManager.getStatsCounter(type); } @Nonnull diff --git oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/session/SessionImpl.java oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/session/SessionImpl.java index 8544008..492e096 100644 --- oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/session/SessionImpl.java +++ oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/session/SessionImpl.java @@ -27,7 +27,6 @@ import java.io.OutputStream; import java.security.AccessControlException; import java.util.Collections; import java.util.Set; -import java.util.concurrent.atomic.AtomicLong; import javax.annotation.CheckForNull; import javax.annotation.Nonnull; @@ -69,6 +68,7 @@ import org.apache.jackrabbit.oak.jcr.session.operation.SessionOperation; import org.apache.jackrabbit.oak.jcr.xml.ImportHandler; import org.apache.jackrabbit.oak.spi.security.authentication.ImpersonationCredentials; import org.apache.jackrabbit.oak.spi.security.authorization.permission.Permissions; +import org.apache.jackrabbit.oak.stats.CounterStats; import org.apache.jackrabbit.util.Text; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -83,14 +83,14 @@ public class SessionImpl implements JackrabbitSession { private SessionContext sessionContext; private SessionDelegate sd; - private final AtomicLong sessionCounter; + private final CounterStats sessionCounter; public SessionImpl(SessionContext sessionContext) { this.sessionContext = sessionContext; this.sd = sessionContext.getSessionDelegate(); - this.sessionCounter = sessionContext.getCounter(SESSION_COUNT); - sessionCounter.incrementAndGet(); - sessionContext.getCounter(Type.SESSION_LOGIN_COUNTER).incrementAndGet(); + this.sessionCounter = sessionContext.getCount(SESSION_COUNT); + sessionCounter.inc(); + sessionContext.getMeter(Type.SESSION_LOGIN_COUNTER).mark(); } static void checkIndexOnName(String jcrPath) throws RepositoryException { @@ -456,7 +456,7 @@ public class SessionImpl implements JackrabbitSession { @Override public void logout() { if (isLive()) { - sessionCounter.decrementAndGet(); + sessionCounter.dec(); try { sd.performVoid(new SessionOperation("logout") { @Override diff --git oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/session/SessionStats.java oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/session/SessionStats.java index d1d096c..3149162 100644 --- oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/session/SessionStats.java +++ oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/session/SessionStats.java @@ -76,7 +76,7 @@ public class SessionStats implements SessionMBean { this.refreshStrategy = refreshStrategy; this.sessionDelegate = sessionDelegate; - long activeSessionCount = statisticManager.getCounter(Type.SESSION_COUNT).get(); + long activeSessionCount = statisticManager.getStatsCounter(Type.SESSION_COUNT).getCount(); initStackTrace = (activeSessionCount > INIT_STACK_TRACE_THRESHOLD) ? new Exception("The session was opened here:") : null; }