• Home
• io.micrometer
• micrometer-core
• 1.7.12
• source code
• MetricsDSLContext.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.micrometer.core.instrument.binder.db.MetricsDSLContext Maven / Gradle / Ivy

/*
 * Copyright 2020 VMware, Inc.
 *
 * Licensed 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
 *
 * https://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 io.micrometer.core.instrument.binder.db;

import io.micrometer.core.annotation.Incubating;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Tag;
import io.micrometer.core.instrument.Tags;
import org.jooq.Record;
import org.jooq.*;
import org.jooq.conf.Settings;
import org.jooq.exception.*;
import org.jooq.impl.DSL;
import org.jooq.tools.jdbc.MockCallable;
import org.jooq.tools.jdbc.MockDataProvider;
import org.jooq.tools.jdbc.MockRunnable;
import org.jooq.util.xml.jaxb.InformationSchema;

import javax.sql.DataSource;
import java.math.BigInteger;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.*;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Executor;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Stream;

/**
 * Time SQL queries passing through jOOQ.
 *
 * Timing of batch operations and with statements not supported.
 * 

 * This can be used as the regular jOOQ {@link DSLContext} but queries will be timed and
 * tags can be set for the query timed. For example: 
 * 
 *     MetricsDSLContext jooq = MetricsDSLContext.withMetrics(DSL.using(configuration), meterRegistry, Tags.empty());
 *     jooq.tag("name", "selectAllAuthors").select(asterisk()).from("author").fetch();
 *  
 *
 * This requires jOOQ 3.14.0 or later.
 *
 * @author Jon Schneider
 * @author Johnny Lim
 * @since 1.4.0
 */
@Incubating(since = "1.4.0")
public class MetricsDSLContext implements DSLContext {

    private final DSLContext context;

    private final MeterRegistry registry;

    private final Iterable tags;

    private final ThreadLocal> contextTags = new ThreadLocal<>();

    private final ExecuteListenerProvider defaultExecuteListenerProvider;

    public static MetricsDSLContext withMetrics(DSLContext jooq, MeterRegistry registry, Iterable tags) {
        return new MetricsDSLContext(jooq, registry, tags);
    }

    MetricsDSLContext(DSLContext context, MeterRegistry registry, Iterable tags) {
        this.registry = registry;
        this.tags = tags;

        this.defaultExecuteListenerProvider = () -> new JooqExecuteListener(registry, tags, () -> {
            Iterable queryTags = contextTags.get();
            contextTags.remove();
            return queryTags;
        });
        Configuration configuration = context.configuration().derive();
        Configuration derivedConfiguration = derive(configuration, this.defaultExecuteListenerProvider);

        this.context = DSL.using(derivedConfiguration);
    }

    public  Q time(Q q) {
        q.attach(time(q.configuration()));
        return q;
    }

    public Configuration time(Configuration c) {
        Iterable queryTags = contextTags.get();
        contextTags.remove();
        return derive(c, () -> new JooqExecuteListener(registry, tags, () -> queryTags));
    }

    private Configuration derive(Configuration configuration, ExecuteListenerProvider executeListenerProvider) {
        ExecuteListenerProvider[] providers = configuration.executeListenerProviders();
        for (int i = 0; i < providers.length; i++) {
            if (providers[i] == this.defaultExecuteListenerProvider) {
                ExecuteListenerProvider[] newProviders = Arrays.copyOf(providers, providers.length);
                newProviders[i] = executeListenerProvider;
                return configuration.derive(newProviders);
            }
        }
        ExecuteListenerProvider[] newProviders = Arrays.copyOf(providers, providers.length + 1);
        newProviders[providers.length] = executeListenerProvider;
        return configuration.derive(newProviders);
    }

    @SuppressWarnings("unchecked")
    public  O timeCoercable(Object o) {
        return (O) time((Query) o);
    }

    public DSLContext tag(String key, String name) {
        return tags(Tags.of(key, name));
    }

    public DSLContext tag(Tag tag) {
        return tags(Tags.of(tag));
    }

    public DSLContext tags(Iterable tags) {
        contextTags.set(tags);
        return this;
    }

    @Override
    public Schema map(Schema schema) {
        return context.map(schema);
    }

    @Override
    public  Table map(Table table) {
        return context.map(table);
    }

    @Override
    public Parser parser() {
        return context.parser();
    }

    @Override
    public Connection parsingConnection() {
        return context.parsingConnection();
    }

    @Override
    public DataSource parsingDataSource() {
        return context.parsingDataSource();
    }

    @Override
    public Connection diagnosticsConnection() {
        return context.diagnosticsConnection();
    }

    @Override
    public DataSource diagnosticsDataSource() {
        return context.diagnosticsDataSource();
    }

    @Override
    public Version version(String id) {
        return context.version(id);
    }

    @Override
    public Migration migrateTo(Version to) {
        return context.migrateTo(to);
    }

    @Override
    public Meta meta() {
        return context.meta();
    }

    @Override
    public Meta meta(DatabaseMetaData meta) {
        return context.meta(meta);
    }

    @Override
    public Meta meta(Catalog... catalogs) {
        return context.meta(catalogs);
    }

    @Override
    public Meta meta(Schema... schemas) {
        return context.meta(schemas);
    }

    @Override
    public Meta meta(Table... tables) {
        return context.meta(tables);
    }

    @Override
    public Meta meta(InformationSchema schema) {
        return context.meta(schema);
    }

    @Override
    public Meta meta(String... sources) {
        return context.meta(sources);
    }

    @Override
    @Internal
    public Meta meta(Source... scripts) {
        return context.meta(scripts);
    }

    @Override
    public Meta meta(Query... queries) {
        return context.meta(queries);
    }

    @Override
    public InformationSchema informationSchema(Catalog catalog) {
        return context.informationSchema(catalog);
    }

    @Override
    public InformationSchema informationSchema(Catalog... catalogs) {
        return context.informationSchema(catalogs);
    }

    @Override
    public InformationSchema informationSchema(Schema schema) {
        return context.informationSchema(schema);
    }

    @Override
    public InformationSchema informationSchema(Schema... schemas) {
        return context.informationSchema(schemas);
    }

    @Override
    public InformationSchema informationSchema(Table table) {
        return context.informationSchema(table);
    }

    @Override
    public InformationSchema informationSchema(Table... table) {
        return context.informationSchema(table);
    }

    @Override
    public Explain explain(Query query) {
        return context.explain(query);
    }

    @Override
    public  T transactionResult(TransactionalCallable transactional) {
        return context.transactionResult(transactional);
    }

    @Override
    public  T transactionResult(ContextTransactionalCallable transactional) throws ConfigurationException {
        return context.transactionResult(transactional);
    }

    @Override
    public void transaction(TransactionalRunnable transactional) {
        context.transaction(transactional);
    }

    @Override
    public void transaction(ContextTransactionalRunnable transactional) throws ConfigurationException {
        context.transaction(transactional);
    }

    @Override
    public  CompletionStage transactionResultAsync(TransactionalCallable transactional)
            throws ConfigurationException {
        return context.transactionResultAsync(transactional);
    }

    @Override
    public CompletionStage transactionAsync(TransactionalRunnable transactional) throws ConfigurationException {
        return context.transactionAsync(transactional);
    }

    @Override
    public  CompletionStage transactionResultAsync(Executor executor, TransactionalCallable transactional)
            throws ConfigurationException {
        return context.transactionResultAsync(executor, transactional);
    }

    @Override
    public CompletionStage transactionAsync(Executor executor, TransactionalRunnable transactional)
            throws ConfigurationException {
        return context.transactionAsync(executor, transactional);
    }

    @Override
    public  T connectionResult(ConnectionCallable callable) {
        return context.connectionResult(callable);
    }

    @Override
    public void connection(ConnectionRunnable runnable) {
        context.connection(runnable);
    }

    @Override
    public  T mockResult(MockDataProvider provider, MockCallable mockable) {
        return context.mockResult(provider, mockable);
    }

    @Override
    public void mock(MockDataProvider provider, MockRunnable mockable) {
        context.mock(provider, mockable);
    }

    @Override
    @Internal
    @Deprecated
    public RenderContext renderContext() {
        return context.renderContext();
    }

    @Override
    public String render(QueryPart part) {
        return context.render(part);
    }

    @Override
    public String renderNamedParams(QueryPart part) {
        return context.renderNamedParams(part);
    }

    @Override
    public String renderNamedOrInlinedParams(QueryPart part) {
        return context.renderNamedOrInlinedParams(part);
    }

    @Override
    public String renderInlined(QueryPart part) {
        return context.renderInlined(part);
    }

    @Override
    public List