From 97796238a575dd8b7bb0eb0decd1f67db69d794e Mon Sep 17 00:00:00 2001 From: Seoyoung Park Date: Fri, 13 Oct 2023 19:03:55 +0900 Subject: [PATCH] [#9794] Add tests, Change minimum version to 0.3.2 --- .../pinpoint/common/trace/ServiceType.java | 2 + plugins-it/clickhouse-jdbc-it/pom.xml | 94 +++++++++++ .../jdbc/clickhouse/ClickHouseITBase.java | 148 +++++++++++++++++ .../jdbc/clickhouse/ClickHouseITHelper.java | 59 +++++++ .../clickhouse/ClickHouseJDBCDriverClass.java | 55 +++++++ .../jdbc/clickhouse/ClickHouseServer.java | 53 ++++++ .../jdbc/clickhouse/ClickHouse_0_3_2_IT.java | 152 ++++++++++++++++++ .../test/resources/pinpoint-clickhouse.config | 88 ++++++++++ .../test/resources/sql/init_clickhouse.sql | 16 ++ .../it/plugin/utils/TestcontainersOption.java | 2 + plugins-it/pom.xml | 1 + plugins/clickhouse-jdbc/pom.xml | 22 ++- .../jdbc/clickhouse/ClickHouseConfig.java | 10 +- .../jdbc/clickhouse/ClickHouseConstants.java | 4 +- .../clickhouse/ClickHouseJdbcUrlParser.java | 16 +- .../jdbc/clickhouse/ClickHousePlugin.java | 71 ++++---- ...ClickHouseConnectionCreateInterceptor.java | 36 ++--- .../ClickHouseSkipInterceptor.java | 4 +- .../ClickHouseJdbcUrlParserTest.java | 61 +++++++ 19 files changed, 812 insertions(+), 82 deletions(-) create mode 100644 plugins-it/clickhouse-jdbc-it/pom.xml create mode 100644 plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseITBase.java create mode 100644 plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseITHelper.java create mode 100644 plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseJDBCDriverClass.java create mode 100644 plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseServer.java create mode 100644 plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouse_0_3_2_IT.java create mode 100644 plugins-it/clickhouse-jdbc-it/src/test/resources/pinpoint-clickhouse.config create mode 100644 plugins-it/clickhouse-jdbc-it/src/test/resources/sql/init_clickhouse.sql create mode 100644 plugins/clickhouse-jdbc/src/test/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseJdbcUrlParserTest.java diff --git a/commons/src/main/java/com/navercorp/pinpoint/common/trace/ServiceType.java b/commons/src/main/java/com/navercorp/pinpoint/common/trace/ServiceType.java index a82f32cf5086a..a5b2d6aeed0f0 100644 --- a/commons/src/main/java/com/navercorp/pinpoint/common/trace/ServiceType.java +++ b/commons/src/main/java/com/navercorp/pinpoint/common/trace/ServiceType.java @@ -144,6 +144,8 @@ * 2751H2_EXECUTE_QUERY * 2752R2DBC_H2 * 2753R2DBC_H2_EXECUTE_QUERY + * 2800CLICK_HOUSE + * 2801CLICK_HOUSE_EXECUTE_QUERY * * *

Database Sandbox (2900 ~ 2999)

diff --git a/plugins-it/clickhouse-jdbc-it/pom.xml b/plugins-it/clickhouse-jdbc-it/pom.xml new file mode 100644 index 0000000000000..962886a791af1 --- /dev/null +++ b/plugins-it/clickhouse-jdbc-it/pom.xml @@ -0,0 +1,94 @@ + + + + + 4.0.0 + + com.navercorp.pinpoint + pinpoint-plugins-it + 2.6.0-SNAPSHOT + + + pinpoint-clickhouse-jdbc-plugin-it + + jar + + + 11 + ${env.JAVA_11_HOME} + + + + + com.navercorp.pinpoint + pinpoint-plugin-it-utils + ${project.version} + + + com.navercorp.pinpoint + pinpoint-plugin-it-utils-jdbc + ${project.version} + + + com.navercorp.pinpoint + pinpoint-clickhouse-jdbc-driver-plugin + ${project.version} + + + + org.testcontainers + testcontainers + ${testcontainers.version} + + + org.testcontainers + clickhouse + 1.19.0 + test + + + com.clickhouse + clickhouse-jdbc + 0.3.2-patch11 + + + com.zaxxer + HikariCP + compile + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + + true + + + + org.apache.maven.plugins + maven-failsafe-plugin + + ${env.JAVA_8_HOME}/bin/java + + + + + diff --git a/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseITBase.java b/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseITBase.java new file mode 100644 index 0000000000000..ff7b90dfaad95 --- /dev/null +++ b/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseITBase.java @@ -0,0 +1,148 @@ +/* + * Copyright 2023 NAVER Corp. + * + * 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 + * + * 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 com.navercorp.pinpoint.it.plugin.jdbc.clickhouse; + +import com.clickhouse.jdbc.ClickHouseConnection; +import com.clickhouse.jdbc.ClickHouseStatement; +import com.navercorp.pinpoint.bootstrap.plugin.jdbc.JdbcUrlParserV2; +import com.navercorp.pinpoint.bootstrap.plugin.test.Expectations; +import com.navercorp.pinpoint.bootstrap.plugin.test.PluginTestVerifier; +import com.navercorp.pinpoint.bootstrap.plugin.test.PluginTestVerifierHolder; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.DataBaseTestCase; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.DefaultJDBCApi; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.DriverProperties; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.JDBCApi; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.JDBCDriverClass; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.testcontainers.DatabaseContainers; +import com.navercorp.pinpoint.plugin.jdbc.clickhouse.ClickHouseJdbcUrlParser; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; + +import javax.sql.DataSource; +import java.lang.reflect.Method; +import java.net.URI; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Collections; + +/** + * @author intr3p1d + */ +public class ClickHouseITBase { + private final Logger logger = LogManager.getLogger(getClass()); + static final String TABLE_NAME = "jdbc_example_basic"; + + protected static DriverProperties driverProperties = DatabaseContainers.readSystemProperties(); + private final ClickHouseITHelper clickHouseITHelper = new ClickHouseITHelper(driverProperties); + + + public static DriverProperties getDriverProperties() { + return driverProperties; + } + + private ClickHouseConnection getConnection() throws SQLException { + return clickHouseITHelper.getConnection(); + } + + public void dropAndCreateTable() throws SQLException { + + PluginTestVerifier verifier = PluginTestVerifierHolder.getInstance(); + verifier.printCache(); + + ClickHouseConnection conn = getConnection(); + String dropAndCreateQuery = String.format( + "drop table if exists %1$s; create table %1$s(a String, b Nullable(String)) engine=Memory", + TABLE_NAME); + + int count; + try (ClickHouseStatement stmt = conn.createStatement()) { + // multi-statement query is supported by default + // session will be created automatically during execution + stmt.execute(dropAndCreateQuery); + count = stmt.getUpdateCount(); + } + + JDBCApi jdbcApi = new DefaultJDBCApi(new ClickHouseJDBCDriverClass()); + + Method connect = jdbcApi.getDriver().getConnect(); + logger.info(verifier.getExecutedMethod()); + verifier.verifyTrace(Expectations.event("CLICK_HOUSE", connect, null, "test", "test", Expectations.cachedArgs("test"))); + + // Method execute = jdbcApi.getPreparedStatement().getExecute(); + // verifier.verifyTrace(Expectations.event("CLICK_HOUSE_EXECUTE_QUERY", execute, null, "test", "test", Expectations.sql(dropAndCreateQuery, null))); + } + + public int query(ClickHouseConnection conn) throws SQLException { + String sql = "select * from " + TABLE_NAME; + try (ClickHouseStatement stmt = conn.createStatement()) { + // set max_result_rows = 3, result_overflow_mode = 'break' + // or simply discard rows after the first 3 in read-only mode + stmt.setMaxRows(3); + int count = 0; + try (ResultSet rs = stmt.executeQuery(sql)) { + while (rs.next()) { + count++; + } + } + return count; + } + } + + public void insertByteArray(ClickHouseConnection conn) throws SQLException { + try (ClickHouseStatement s = conn.createStatement()) { + s.execute("drop table if exists t_map;" + + "CREATE TABLE t_map" + + "(" + + " `audit_seq` Int64 CODEC(Delta(8), LZ4)," + + "`timestamp` Int64 CODEC(Delta(8), LZ4)," + + "`event_type` LowCardinality(String)," + + "`event_subtype` LowCardinality(String)," + + "`actor_type` LowCardinality(String)," + + "`actor_id` String," + + "`actor_tenant_id` LowCardinality(String)," + + "`actor_tenant_name` String," + + "`actor_firstname` String," + + "`actor_lastname` String," + + "`resource_type` LowCardinality(String)," + + "`resource_id` String," + + "`resource_container` LowCardinality(String)," + + "`resource_path` String," + + "`origin_ip` String," + + "`origin_app_name` LowCardinality(String)," + + "`origin_app_instance` String," + + "`description` String," + + "`attributes` Map(String, String)" + + ")" + + "ENGINE = MergeTree " + + "ORDER BY (resource_container, event_type, event_subtype) " + + "SETTINGS index_granularity = 8192"); + try (PreparedStatement stmt = conn.prepareStatement( + "INSERT INTO t_map SETTINGS async_insert=1,wait_for_async_insert=1 VALUES (8481365034795008,1673349039830,'operation-9','a','service', 'bc3e47b8-2b34-4c1a-9004-123656fa0000','b', 'c', 'service-56','d', 'object','e', 'my-value-62', 'mypath', 'some.hostname.address.com', 'app-9', 'instance-6','x', ?)")) { + stmt.setObject(1, Collections.singletonMap("key1", "value1")); + stmt.execute(); + + try (ResultSet rs = s.executeQuery("select attributes from t_map")) { + logger.info(rs.next()); + logger.info(rs.getObject(1)); + } + } + } + } + +} diff --git a/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseITHelper.java b/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseITHelper.java new file mode 100644 index 0000000000000..b08a383c11d91 --- /dev/null +++ b/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseITHelper.java @@ -0,0 +1,59 @@ +/* + * Copyright 2023 NAVER Corp. + * + * 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 + * + * 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 com.navercorp.pinpoint.it.plugin.jdbc.clickhouse; + +import com.clickhouse.jdbc.ClickHouseConnection; +import com.clickhouse.jdbc.ClickHouseDriver; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.DriverProperties; + +import java.sql.SQLException; +import java.util.Objects; +import java.util.Properties; + +/** + * @author intr3p1d + */ +public class ClickHouseITHelper { + + private final String jdbcUrl; + private final String userName; + private final String password; + + + public ClickHouseITHelper(DriverProperties driverProperties) { + Objects.requireNonNull(driverProperties, "driverProperties"); + + this.jdbcUrl = driverProperties.getUrl(); + this.userName = driverProperties.getUser(); + this.password = driverProperties.getPassword(); + + } + + public ClickHouseConnection getConnection() throws SQLException { + ClickHouseDriver driver = new ClickHouseDriver(); + Properties properties = new Properties(); + properties.put("user", userName); + properties.put("password", password); + + // final Connection conn = DriverManager.getConnection(jdbcUrl, userName, password); + final ClickHouseConnection conn = driver.connect(jdbcUrl, properties); + + System.out.println("Connected to: " + conn.getMetaData().getURL()); + return conn; + } + +} + diff --git a/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseJDBCDriverClass.java b/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseJDBCDriverClass.java new file mode 100644 index 0000000000000..f5a62f0cfe40b --- /dev/null +++ b/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseJDBCDriverClass.java @@ -0,0 +1,55 @@ +/* + * Copyright 2023 NAVER Corp. + * + * 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 + * + * 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 com.navercorp.pinpoint.it.plugin.jdbc.clickhouse; + +import com.navercorp.pinpoint.it.plugin.utils.jdbc.AbstractJDBCDriverClass; + +import java.sql.CallableStatement; +import java.sql.Connection; +import java.sql.Driver; +import java.sql.PreparedStatement; +import java.sql.Statement; + +/** + * @author intr3p1d + */ +public class ClickHouseJDBCDriverClass extends AbstractJDBCDriverClass { + @Override + public Class getDriver() { + return forName("com.clickhouse.jdbc.ClickHouseDriver"); + } + + @Override + public Class getConnection() { + return forName("com.clickhouse.jdbc.ClickHouseConnection"); + } + + @Override + public Class getStatement() { + return forName("com.clickhouse.jdbc.ClickHouseStatement"); + } + + @Override + public Class getPreparedStatement() { + return forName("com.clickhouse.jdbc.internal.InputBasedPreparedStatement"); + } + + @Override + public Class getCallableStatement() { + // Unsupported + return null; + } +} diff --git a/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseServer.java b/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseServer.java new file mode 100644 index 0000000000000..a3ddae0446182 --- /dev/null +++ b/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouseServer.java @@ -0,0 +1,53 @@ +/* + * Copyright 2023 NAVER Corp. + * + * 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 + * + * 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 com.navercorp.pinpoint.it.plugin.jdbc.clickhouse; + +import com.navercorp.pinpoint.it.plugin.utils.jdbc.testcontainers.DatabaseContainers; +import com.navercorp.pinpoint.test.plugin.shared.SharedTestLifeCycle; +import org.junit.jupiter.api.Assumptions; +import org.testcontainers.DockerClientFactory; +import org.testcontainers.clickhouse.ClickHouseContainer; +import org.testcontainers.utility.DockerImageName; + +import java.util.Properties; + +/** + * @author intr3p1d + */ +public class ClickHouseServer implements SharedTestLifeCycle { + private static final String CLICKHOUSE_IMAGE = "clickhouse/clickhouse-server:23.9.1.1854"; + private ClickHouseContainer container; + + @Override + public Properties beforeAll() { + Assumptions.assumeTrue(DockerClientFactory.instance().isDockerAvailable(), "Docker not enabled"); + container = new ClickHouseContainer(DockerImageName.parse(CLICKHOUSE_IMAGE)); + container.withDatabaseName("default"); + container.withUsername("default"); + container.withPassword(""); + container.withInitScript("sql/init_clickhouse.sql"); + container.start(); + + return DatabaseContainers.toProperties(container); + } + + @Override + public void afterAll() { + if (container != null) { + container.stop(); + } + } +} diff --git a/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouse_0_3_2_IT.java b/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouse_0_3_2_IT.java new file mode 100644 index 0000000000000..fcccdb8947d70 --- /dev/null +++ b/plugins-it/clickhouse-jdbc-it/src/test/java/com/navercorp/pinpoint/it/plugin/jdbc/clickhouse/ClickHouse_0_3_2_IT.java @@ -0,0 +1,152 @@ +/* + * Copyright 2023 NAVER Corp. + * + * 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 + * + * 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 com.navercorp.pinpoint.it.plugin.jdbc.clickhouse; + +import com.clickhouse.jdbc.ClickHouseConnection; +import com.navercorp.pinpoint.bootstrap.plugin.jdbc.JdbcUrlParserV2; +import com.navercorp.pinpoint.bootstrap.plugin.test.PluginTestVerifier; +import com.navercorp.pinpoint.bootstrap.plugin.test.PluginTestVerifierHolder; +import com.navercorp.pinpoint.it.plugin.utils.AgentPath; +import com.navercorp.pinpoint.it.plugin.utils.PluginITConstants; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.DataBaseTestCase; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.DefaultJDBCApi; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.DriverProperties; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.JDBCApi; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.JDBCDriverClass; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.JDBCTestConstants; +import com.navercorp.pinpoint.it.plugin.utils.jdbc.testcontainers.DatabaseContainers; +import com.navercorp.pinpoint.plugin.jdbc.clickhouse.ClickHouseJdbcUrlParser; +import com.navercorp.pinpoint.test.plugin.Dependency; +import com.navercorp.pinpoint.test.plugin.PinpointAgent; +import com.navercorp.pinpoint.test.plugin.PinpointConfig; +import com.navercorp.pinpoint.test.plugin.PluginTest; +import com.navercorp.pinpoint.test.plugin.shared.SharedDependency; +import com.navercorp.pinpoint.test.plugin.shared.SharedTestBeforeAllResult; +import com.navercorp.pinpoint.test.plugin.shared.SharedTestLifeCycleClass; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.net.URI; +import java.sql.SQLException; +import java.util.Properties; + +/** + * @author intr3p1d + */ +@PluginTest +@PinpointAgent(AgentPath.PATH) +@Dependency({ + "com.clickhouse:clickhouse-jdbc:[0.3.2-patch11]", + "log4j:log4j:1.2.16", "org.slf4j:slf4j-log4j12:1.7.5", + JDBCTestConstants.VERSION}) +@PinpointConfig("pinpoint-clickhouse.config") +@SharedDependency({ + "com.clickhouse:clickhouse-jdbc:[0.3.2-patch11]", + PluginITConstants.VERSION, JDBCTestConstants.VERSION, + "org.testcontainers:testcontainers:1.19.0", + "org.testcontainers:clickhouse:1.19.0" +}) +@SharedTestLifeCycleClass(ClickHouseServer.class) +public class ClickHouse_0_3_2_IT extends DataBaseTestCase { + + private final static String CLICK_HOUSE = "CLICK_HOUSE"; + private final static String CLICK_HOUSE_EXECUTE_QUERY = "CLICK_HOUSE_EXECUTE_QUERY"; + + private final Logger logger = LogManager.getLogger(getClass()); + protected static DriverProperties driverProperties = DatabaseContainers.readSystemProperties(); + private static URI uri; + + private final ClickHouseITHelper clickHouseITHelper = new ClickHouseITHelper(driverProperties); + private final ClickHouseITBase clickHouseITBase = new ClickHouseITBase(); + + + private static JDBCDriverClass driverClass; + private static JDBCApi jdbcApi; + + private static JdbcUrlParserV2 jdbcUrlParser; + + public static DriverProperties getDriverProperties() { + return driverProperties; + } + + @SharedTestBeforeAllResult + public static void setBeforeAllResult(Properties beforeAllResult) { + } + + @BeforeAll + public static void setUpBeforeClass() throws Exception { + DriverProperties driverProperties = getDriverProperties(); + driverClass = new ClickHouseJDBCDriverClass(); + jdbcApi = new DefaultJDBCApi(driverClass); + + jdbcUrlParser = new ClickHouseJdbcUrlParser(); + } + + @Override + protected JDBCDriverClass getJDBCDriverClass() { + return driverClass; + } + + @BeforeEach + public void before() { + logger.info("before"); + setup(CLICK_HOUSE, CLICK_HOUSE_EXECUTE_QUERY, driverProperties, jdbcUrlParser, jdbcApi); + } + + private ClickHouseConnection getConnection() throws SQLException { + return clickHouseITHelper.getConnection(); + } + + @Override + public void testStatement() throws Exception { + super.testStatement(); + } + + @Override + public void testStoredProcedure_with_IN_OUT_parameters() throws Exception { + super.testStoredProcedure_with_IN_OUT_parameters(); + } + + @Override + public void testStoredProcedure_with_INOUT_parameters() throws Exception { + super.testStoredProcedure_with_INOUT_parameters(); + } + + @Test + public void testDropAndCreateTable() throws SQLException { + clickHouseITBase.dropAndCreateTable(); + } + + @Test + public void test1() throws SQLException { + PluginTestVerifier verifier = PluginTestVerifierHolder.getInstance(); + ClickHouseConnection conn = getConnection(); + clickHouseITBase.query(conn); + logger.info(verifier.getExecutedMethod()); + } + + @Test + public void test2() throws SQLException { + PluginTestVerifier verifier = PluginTestVerifierHolder.getInstance(); + ClickHouseConnection conn = getConnection(); + clickHouseITBase.insertByteArray(conn); + logger.info(verifier.getExecutedMethod()); + } + +} diff --git a/plugins-it/clickhouse-jdbc-it/src/test/resources/pinpoint-clickhouse.config b/plugins-it/clickhouse-jdbc-it/src/test/resources/pinpoint-clickhouse.config new file mode 100644 index 0000000000000..3de2b153efb80 --- /dev/null +++ b/plugins-it/clickhouse-jdbc-it/src/test/resources/pinpoint-clickhouse.config @@ -0,0 +1,88 @@ +# +# Pinpoint agent configuration +# (Phase : local) +# + +########################################################### +# Collector server # +########################################################### +# local +profiler.collector.ip=127.0.0.1 +# dev +#profiler.collector.ip=dev.collector.pinpoint.navercorp.com +# real +#profiler.collector.ip=collector.pinpoint.navercorp.com + +# placeHolder support "${key}" +profiler.collector.span.ip=${profiler.collector.ip} +profiler.collector.span.port=9996 + +# placeHolder support "${key}" +profiler.collector.stat.ip=${profiler.collector.ip} +profiler.collector.stat.port=9995 + +# placeHolder support "${key}" +profiler.collector.tcp.ip=${profiler.collector.ip} +profiler.collector.tcp.port=9994 + + +########################################################### +# Profiler Global Configuration # +########################################################### +profiler.enable=true + +# Application namespace +# Differentiate from external pinpoint agents. (e.g., com.pinpoint) +profiler.application.namespace= + +# Manually override jvm vendor name (Oracle, IBM, OpenJDK, etc) +# You probably won't ever need to set this value. +profiler.jvm.vendor.name= + +# Interval (in milliseconds) at which agent stat data is collected. (default : 5000, min : 1000, max : 5000) +profiler.jvm.stat.collect.interval=5000 +# Number of agent stat data sent to the collector in a single batch. (default : 6) +profiler.jvm.stat.batch.send.count=6 + +# Allow to add detailed collector's metrics +profiler.jvm.stat.collect.detailed.metrics=false + +profiler.sampling.enable=true +profiler.sampling.rate=1 + +profiler.io.buffering.enable=true + +profiler.io.buffering.buffersize=20 + + + +profiler.spandatasender.write.queue.size=5120 +#profiler.spandatasender.socket.sendbuffersize=1048576 +#profiler.spandatasender.socket.timeout=3000 +profiler.spandatasender.chunk.size=16384 + +profiler.statdatasender.write.queue.size=5120 +#profiler.statdatasender.socket.sendbuffersize=1048576 +#profiler.statdatasender.socket.timeout=3000 +profiler.statdatasender.chunk.size=16384 + +profiler.agentInfo.send.retry.interval=300000 + +profiler.tcpdatasender.command.accept.enable=true + +########################################################### +# application type # +########################################################### +#profiler.applicationservertype=TOMCAT +#profiler.applicationservertype=BLOC + +# +# CLICKHOUSE JDBC +# +# Profile Mssql +profiler.jdbc.clickhouse=true +profiler.jdbc.clickhouse.setautocommit=true +profiler.jdbc.clickhouse.commit=true +profiler.jdbc.clickhouse.rollback=true +profiler.jdbc.clickhouse.tracesqlbindvalue=true + diff --git a/plugins-it/clickhouse-jdbc-it/src/test/resources/sql/init_clickhouse.sql b/plugins-it/clickhouse-jdbc-it/src/test/resources/sql/init_clickhouse.sql new file mode 100644 index 0000000000000..e1735a34346a7 --- /dev/null +++ b/plugins-it/clickhouse-jdbc-it/src/test/resources/sql/init_clickhouse.sql @@ -0,0 +1,16 @@ + +CREATE TABLE member +( + id Int64, + name String, + joined DateTime('Asia/Seoul') DEFAULT now() +) ENGINE = MergeTree() +ORDER BY id; + +CREATE TABLE test +( + id Int64, + name String, + age Int32 +) ENGINE = MergeTree() +ORDER BY id; diff --git a/plugins-it/plugins-it-utils/src/main/java/com/navercorp/pinpoint/it/plugin/utils/TestcontainersOption.java b/plugins-it/plugins-it-utils/src/main/java/com/navercorp/pinpoint/it/plugin/utils/TestcontainersOption.java index c7ee9cfbd163f..dd95ee67998a7 100644 --- a/plugins-it/plugins-it-utils/src/main/java/com/navercorp/pinpoint/it/plugin/utils/TestcontainersOption.java +++ b/plugins-it/plugins-it-utils/src/main/java/com/navercorp/pinpoint/it/plugin/utils/TestcontainersOption.java @@ -36,4 +36,6 @@ private TestcontainersOption() { public static final String MONGODB = "org.testcontainers:mongodb:" + VERSION; public static final String KAFKA = "org.testcontainers:kafka:" + VERSION; public static final String RABBITMQ = "org.testcontainers:rabbitmq:" + VERSION; + + public static final String CLICKHOUSE = "org.testcontainers:clickhouse" + VERSION; } diff --git a/plugins-it/pom.xml b/plugins-it/pom.xml index a4489f18a4058..79963efaaae37 100644 --- a/plugins-it/pom.xml +++ b/plugins-it/pom.xml @@ -33,6 +33,7 @@ plugins-it-utils-jdbc activemq-it cassandra-it + clickhouse-jdbc-it cxf-it druid-it dubbo-it diff --git a/plugins/clickhouse-jdbc/pom.xml b/plugins/clickhouse-jdbc/pom.xml index 78fd4eafb99c0..eb74bab2c187c 100644 --- a/plugins/clickhouse-jdbc/pom.xml +++ b/plugins/clickhouse-jdbc/pom.xml @@ -5,7 +5,7 @@ com.navercorp.pinpoint pinpoint-plugins - 2.0.3 + 2.6.0-SNAPSHOT pinpoint-clickhouse-jdbc-driver-plugin @@ -26,23 +26,29 @@ test - org.slf4j - slf4j-log4j12 + org.apache.logging.log4j + log4j-core + test + + + org.apache.logging.log4j + log4j-api test - log4j - log4j + org.apache.logging.log4j + log4j-slf4j-impl test + - ru.yandex.clickhouse + com.clickhouse clickhouse-jdbc - 0.2 - provided + 0.3.2-patch11 + diff --git a/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseConfig.java b/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseConfig.java index 8058f97b1ddb9..1b9bf33ccd33f 100644 --- a/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseConfig.java +++ b/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseConfig.java @@ -26,12 +26,12 @@ public class ClickHouseConfig extends JdbcConfig { private final boolean profileRollback; public ClickHouseConfig(ProfilerConfig config) { - super(config.readBoolean("profiler.jdbc.mysql", false), - config.readBoolean("profiler.jdbc.mysql.tracesqlbindvalue", config.isTraceSqlBindValue()), + super(config.readBoolean("profiler.jdbc.clickhouse", false), + config.readBoolean("profiler.jdbc.clickhouse.tracesqlbindvalue", config.isTraceSqlBindValue()), config.getMaxSqlBindValueSize()); - this.profileSetAutoCommit = config.readBoolean("profiler.jdbc.mysql.setautocommit", false); - this.profileCommit = config.readBoolean("profiler.jdbc.mysql.commit", false); - this.profileRollback = config.readBoolean("profiler.jdbc.mysql.rollback", false); + this.profileSetAutoCommit = config.readBoolean("profiler.jdbc.clickhouse.setautocommit", false); + this.profileCommit = config.readBoolean("profiler.jdbc.clickhouse.commit", false); + this.profileRollback = config.readBoolean("profiler.jdbc.clickhouse.rollback", false); } public boolean isProfileSetAutoCommit() { diff --git a/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseConstants.java b/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseConstants.java index 2949128379fbe..e22ab7a291249 100644 --- a/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseConstants.java +++ b/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseConstants.java @@ -14,7 +14,9 @@ */ package com.navercorp.pinpoint.plugin.jdbc.clickhouse; -import static com.navercorp.pinpoint.common.trace.ServiceTypeProperty.*; +import static com.navercorp.pinpoint.common.trace.ServiceTypeProperty.INCLUDE_DESTINATION_ID; +import static com.navercorp.pinpoint.common.trace.ServiceTypeProperty.RECORD_STATISTICS; +import static com.navercorp.pinpoint.common.trace.ServiceTypeProperty.TERMINAL; import com.navercorp.pinpoint.common.trace.ServiceType; import com.navercorp.pinpoint.common.trace.ServiceTypeFactory; diff --git a/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseJdbcUrlParser.java b/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseJdbcUrlParser.java index d8aa31f99ff21..6bc99b4ea21e0 100644 --- a/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseJdbcUrlParser.java +++ b/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseJdbcUrlParser.java @@ -34,9 +34,10 @@ */ public class ClickHouseJdbcUrlParser implements JdbcUrlParserV2 { + // >=0.3.2 + // jdbc:(ch|clickhouse)[:protocol]://endpoint[,endpoint][/database][?parameters][#tags] static final String URL_PREFIX = "jdbc:clickhouse:"; - // jdbc:mysql:loadbalance://10.22.33.44:3306,10.22.33.55:3306/MySQL?characterEncoding=UTF-8 - private static final String LOADBALANCE_URL_PREFIX = URL_PREFIX + "loadbalance:"; + static final String URL_SHORT_PREFIX = "jdbc:ch:"; private final PLogger logger = PLoggerFactory.getLogger(this.getClass()); @@ -46,7 +47,7 @@ public DatabaseInfo parse(String jdbcUrl) { logger.info("jdbcUrl must not be null"); return UnKnownDatabaseInfo.INSTANCE; } - if (!jdbcUrl.startsWith(URL_PREFIX)) { + if (!jdbcUrl.startsWith(URL_PREFIX) && !jdbcUrl.startsWith(URL_SHORT_PREFIX)) { logger.info("jdbcUrl has invalid prefix.(url:{}, prefix:{})", jdbcUrl, URL_PREFIX); return UnKnownDatabaseInfo.INSTANCE; } @@ -63,12 +64,17 @@ public DatabaseInfo parse(String jdbcUrl) { } private DatabaseInfo parse0(String jdbcUrl) { - // jdbc:mysql://1.2.3.4:5678/test_db + // jdbc:(ch|clickhouse)[:protocol]://endpoint[,endpoint][/database][?parameters][#tags] StringMaker maker = new StringMaker(jdbcUrl); maker.after(URL_PREFIX); + maker.after(URL_SHORT_PREFIX); + + // [:protocol]://endpoint[,endpoint][/database][?parameters][#tags] + // endpoint: [protocol://]host[:port][/database][?parameters][#tags] + // protocol: (grpc|grpcs|http|https|tcp|tcps) // 1.2.3.4:5678 In case of replication driver could have multiple values // We have to consider mm db too. - String host = maker.after("//").before('/').value(); + String host = maker.after("//").beforeLast('/').value(); List hostList = parseHost(host); String databaseId = maker.next().after('/').before('?').value(); String normalizedUrl = maker.clear().before('?').value(); diff --git a/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHousePlugin.java b/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHousePlugin.java index 6af6a2eea1a5b..f40e8deacb83d 100644 --- a/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHousePlugin.java +++ b/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHousePlugin.java @@ -32,9 +32,6 @@ import com.navercorp.pinpoint.bootstrap.plugin.jdbc.ParsingResultAccessor; import com.navercorp.pinpoint.bootstrap.plugin.jdbc.PreparedStatementBindingMethodFilter; import com.navercorp.pinpoint.bootstrap.plugin.jdbc.JdbcUrlParserV2; -import com.navercorp.pinpoint.bootstrap.plugin.jdbc.interceptor.CallableStatementBindVariableInterceptor; -import com.navercorp.pinpoint.bootstrap.plugin.jdbc.interceptor.CallableStatementExecuteQueryInterceptor; -import com.navercorp.pinpoint.bootstrap.plugin.jdbc.interceptor.CallableStatementRegisterOutParameterInterceptor; import com.navercorp.pinpoint.bootstrap.plugin.jdbc.interceptor.ConnectionCloseInterceptor; import com.navercorp.pinpoint.bootstrap.plugin.jdbc.interceptor.DriverConnectInterceptorV2; import com.navercorp.pinpoint.bootstrap.plugin.jdbc.interceptor.PreparedStatementBindVariableInterceptor; @@ -48,7 +45,6 @@ import com.navercorp.pinpoint.bootstrap.plugin.jdbc.interceptor.TransactionSetAutoCommitInterceptor; import com.navercorp.pinpoint.bootstrap.plugin.util.InstrumentUtils; import com.navercorp.pinpoint.plugin.jdbc.clickhouse.interceptor.ClickHouseConnectionCreateInterceptor; -import com.navercorp.pinpoint.plugin.jdbc.clickhouse.interceptor.ClickHouseSkipInterceptor; import java.security.ProtectionDomain; import java.util.List; @@ -87,9 +83,8 @@ public void setup(ProfilerPluginSetupContext context) { private void addConnectionTransformer(final ClickHouseConfig config) { - - transformTemplate.transform("ru.yandex.clickhouse.ClickHouseConnection", ConnectionTransform.class); - transformTemplate.transform("ru.yandex.clickhouse.ClickHouseConnectionImpl", ConnectionTransform.class); + transformTemplate.transform("com.clickhouse.jdbc.ClickHouseConnection", ConnectionTransform.class); + transformTemplate.transform("com.clickhouse.jdbc.ClickHouseConnectionImpl", ConnectionTransform.class); } @@ -105,16 +100,18 @@ public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, Strin target.addField(DatabaseInfoAccessor.class); - InstrumentMethod constructor = target.getConstructor("java.lang.String", "ru.yandex.clickhouse.settings.ClickHouseProperties"); - if (constructor != null) { - constructor.addInterceptor(ClickHouseConnectionCreateInterceptor.class); + InstrumentMethod constructor1 = target.getConstructor("java.lang.String"); + if (constructor1 != null) { + constructor1.addInterceptor(ClickHouseConnectionCreateInterceptor.class); + } + InstrumentMethod constructor2 = target.getConstructor("java.lang.String", "java.util.Properties"); + if (constructor2 != null) { + constructor2.addInterceptor(ClickHouseConnectionCreateInterceptor.class); + } + InstrumentMethod constructor3 = target.getConstructor("com.clickhouse.jdbc.internal.ClickHouseJdbcUrlParser.ConnectionInfo"); + if (constructor3 != null) { + constructor3.addInterceptor(ClickHouseConnectionCreateInterceptor.class); } - - // initTimeZone - InstrumentUtils.findMethod(target, "initTimeZone","ru.yandex.clickhouse.settings.ClickHouseProperties") - .addScopedInterceptor(ClickHouseSkipInterceptor.class, CLICK_HOUSE_SCOPE); - - // close InstrumentUtils.findMethod(target, "close") @@ -131,30 +128,30 @@ public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, Strin // preparedStatement final Class preparedStatementCreate = PreparedStatementCreateInterceptor.class; - InstrumentUtils.findMethod(target, "prepareStatement", "java.lang.String") + InstrumentUtils.findMethod(target, "prepareStatement", "java.lang.String") .addScopedInterceptor(preparedStatementCreate, CLICK_HOUSE_SCOPE); - InstrumentUtils.findMethod(target, "prepareStatement", "java.lang.String", "int") + InstrumentUtils.findMethod(target, "prepareStatement", "java.lang.String", "int") .addScopedInterceptor(preparedStatementCreate, CLICK_HOUSE_SCOPE); - InstrumentUtils.findMethod(target, "prepareStatement", "java.lang.String", "int[]") + InstrumentUtils.findMethod(target, "prepareStatement", "java.lang.String", "int[]") .addScopedInterceptor(preparedStatementCreate, CLICK_HOUSE_SCOPE); - InstrumentUtils.findMethod(target, "prepareStatement", "java.lang.String", "java.lang.String[]") + InstrumentUtils.findMethod(target, "prepareStatement", "java.lang.String", "java.lang.String[]") .addScopedInterceptor(preparedStatementCreate, CLICK_HOUSE_SCOPE); - InstrumentUtils.findMethod(target, "prepareStatement", "java.lang.String", "int", "int") + InstrumentUtils.findMethod(target, "prepareStatement", "java.lang.String", "int", "int") .addScopedInterceptor(preparedStatementCreate, CLICK_HOUSE_SCOPE); - InstrumentUtils.findMethod(target, "prepareStatement", "java.lang.String", "int", "int", "int") + InstrumentUtils.findMethod(target, "prepareStatement", "java.lang.String", "int", "int", "int") .addScopedInterceptor(preparedStatementCreate, CLICK_HOUSE_SCOPE); // preparecall - InstrumentUtils.findMethod(target, "prepareCall", "java.lang.String") + InstrumentUtils.findMethod(target, "prepareCall", "java.lang.String") .addScopedInterceptor(preparedStatementCreate, CLICK_HOUSE_SCOPE); - InstrumentUtils.findMethod(target, "prepareCall", "java.lang.String", "int", "int") + InstrumentUtils.findMethod(target, "prepareCall", "java.lang.String", "int", "int") .addScopedInterceptor(preparedStatementCreate, CLICK_HOUSE_SCOPE); - InstrumentUtils.findMethod(target, "prepareCall", "java.lang.String", "int", "int", "int") + InstrumentUtils.findMethod(target, "prepareCall", "java.lang.String", "int", "int", "int") .addScopedInterceptor(preparedStatementCreate, CLICK_HOUSE_SCOPE); ClickHouseConfig config = new ClickHouseConfig(instrumentor.getProfilerConfig()); if (config.isProfileSetAutoCommit()) { - InstrumentUtils.findMethod(target, "setAutoCommit", "boolean") + InstrumentUtils.findMethod(target, "setAutoCommit", "boolean") .addScopedInterceptor(TransactionSetAutoCommitInterceptor.class, CLICK_HOUSE_SCOPE); } @@ -174,7 +171,7 @@ public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, Strin private void addDriverTransformer() { - transformTemplate.transform("ru.yandex.clickhouse.ClickHouseDriver", DriverTransform.class); + transformTemplate.transform("com.clickhouse.jdbc.ClickHouseDriver", DriverTransform.class); } @@ -184,7 +181,7 @@ public static class DriverTransform implements TransformCallback { public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, String className, Class classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws InstrumentException { InstrumentClass target = instrumentor.getInstrumentClass(loader, className, classfileBuffer); - InstrumentUtils.findMethod(target, "connect", "java.lang.String", "java.util.Properties") + InstrumentUtils.findMethod(target, "connect", "java.lang.String", "java.util.Properties") .addScopedInterceptor(DriverConnectInterceptorV2.class, va(ClickHouseConstants.CLICK_HOUSE, false), CLICK_HOUSE_SCOPE, ExecutionPolicy.ALWAYS); return target.toBytecode(); @@ -193,7 +190,11 @@ public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, Strin private void addPreparedStatementTransformer(final ClickHouseConfig config) { - transformTemplate.transform("ru.yandex.clickhouse.ClickHousePreparedStatementImpl", PreparedStatementTransform.class); + transformTemplate.transform("com.clickhouse.jdbc.ClickHousePreparedStatement", PreparedStatementTransform.class); + + transformTemplate.transform("com.clickhouse.jdbc.internal.InputBasedPreparedStatement", PreparedStatementTransform.class); + transformTemplate.transform("com.clickhouse.jdbc.internal.SqlBasedPreparedStatement", PreparedStatementTransform.class); + transformTemplate.transform("com.clickhouse.jdbc.internal.TableBasedPreparedStatement", PreparedStatementTransform.class); } @@ -239,10 +240,8 @@ public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, Strin private void addStatementTransformer() { - - transformTemplate.transform("ru.yandex.clickhouse.ClickHouseStatement", StatementTransformer.class); - transformTemplate.transform("ru.yandex.clickhouse.ClickHouseStatementImpl", StatementTransformer.class); - + transformTemplate.transform("com.clickhouse.jdbc.ClickHouseStatement", StatementTransformer.class); + transformTemplate.transform("com.clickhouse.jdbc.ClickHouseStatementImpl", StatementTransformer.class); } @@ -265,11 +264,11 @@ public byte[] doInTransform(Instrumentor instrumentor, ClassLoader loader, Strin final Class executeUpdateInterceptor = StatementExecuteUpdateInterceptor.class; InstrumentUtils.findMethod(target, "executeUpdate", "java.lang.String") .addScopedInterceptor(executeUpdateInterceptor, CLICK_HOUSE_SCOPE); - InstrumentUtils.findMethod(target, "executeUpdate", "java.lang.String", "int") + InstrumentUtils.findMethod(target, "executeUpdate", "java.lang.String", "int") .addScopedInterceptor(executeUpdateInterceptor, CLICK_HOUSE_SCOPE); - InstrumentUtils.findMethod(target, "execute", "java.lang.String") + InstrumentUtils.findMethod(target, "execute", "java.lang.String") .addScopedInterceptor(executeUpdateInterceptor, CLICK_HOUSE_SCOPE); - InstrumentUtils.findMethod(target, "execute", "java.lang.String", "int") + InstrumentUtils.findMethod(target, "execute", "java.lang.String", "int") .addScopedInterceptor(executeUpdateInterceptor, CLICK_HOUSE_SCOPE); return target.toBytecode(); diff --git a/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/interceptor/ClickHouseConnectionCreateInterceptor.java b/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/interceptor/ClickHouseConnectionCreateInterceptor.java index 1ac03e98f9f0a..008d3e0c8c578 100644 --- a/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/interceptor/ClickHouseConnectionCreateInterceptor.java +++ b/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/interceptor/ClickHouseConnectionCreateInterceptor.java @@ -17,6 +17,7 @@ package com.navercorp.pinpoint.plugin.jdbc.clickhouse.interceptor; import java.util.Arrays; +import java.util.Properties; import com.navercorp.pinpoint.bootstrap.context.DatabaseInfo; import com.navercorp.pinpoint.bootstrap.context.SpanEventRecorder; @@ -29,7 +30,6 @@ import com.navercorp.pinpoint.bootstrap.plugin.jdbc.DefaultDatabaseInfo; import com.navercorp.pinpoint.bootstrap.util.InterceptorUtils; import com.navercorp.pinpoint.plugin.jdbc.clickhouse.ClickHouseConstants; -import ru.yandex.clickhouse.settings.ClickHouseProperties; /** * @author emeroad @@ -53,7 +53,7 @@ public void after(Object target, Object[] args, Object result, Throwable throwab if (isDebug) { logger.afterInterceptor(target, args, result, throwable); } - if (args == null ) { + if (args == null) { return; } @@ -61,15 +61,15 @@ public void after(Object target, Object[] args, Object result, Throwable throwab DatabaseInfo databaseInfo = null; - if(args[1] instanceof ClickHouseProperties){ - ClickHouseProperties clickHouseProperties=(ClickHouseProperties)args[1]; - String databaseId=clickHouseProperties.getDatabase(); + if (args[1] instanceof Properties) { + Properties clickHouseProperties = (Properties) args[1]; + String databaseId = clickHouseProperties.getProperty("database"); if (url != null && databaseId != null) { - String tmpURL=url.substring(url.lastIndexOf("/")+1); + String tmpURL = url.substring(url.lastIndexOf("/") + 1); // It's dangerous to use this url directly - databaseInfo = new DefaultDatabaseInfo(ClickHouseConstants.CLICK_HOUSE, ClickHouseConstants.CLICK_HOUSE_EXECUTE_QUERY, tmpURL, tmpURL, Arrays.asList(tmpURL), databaseId); + databaseInfo = createDatabaseInfo(tmpURL, databaseId); if (InterceptorUtils.isSuccess(throwable)) { // Set only if connection is success. if (target instanceof DatabaseInfoAccessor) { @@ -77,12 +77,11 @@ public void after(Object target, Object[] args, Object result, Throwable throwab } } } - }else { + } else { return; } - final Trace trace = traceContext.currentTraceObject(); if (trace == null) { return; @@ -97,15 +96,9 @@ public void after(Object target, Object[] args, Object result, Throwable throwab } } - - private DatabaseInfo createDatabaseInfo(String url, Integer port, String databaseId) { - if (url.indexOf(':') == -1) { - url += ":" + port; - } - - DatabaseInfo databaseInfo = new DefaultDatabaseInfo(ClickHouseConstants.CLICK_HOUSE, ClickHouseConstants.CLICK_HOUSE_EXECUTE_QUERY, url, url, Arrays.asList(url), databaseId); - return databaseInfo; + private DatabaseInfo createDatabaseInfo(String url, String databaseId) { + return new DefaultDatabaseInfo(ClickHouseConstants.CLICK_HOUSE, ClickHouseConstants.CLICK_HOUSE_EXECUTE_QUERY, url, url, Arrays.asList(url), databaseId); } private String getString(Object value) { @@ -115,15 +108,8 @@ private String getString(Object value) { return null; } - private Integer getInteger(Object value) { - if (value instanceof Integer) { - return (Integer) value; - } - return null; - } - @Override public void before(Object target, Object[] args) { - + // ignore } } diff --git a/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/interceptor/ClickHouseSkipInterceptor.java b/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/interceptor/ClickHouseSkipInterceptor.java index 1113aad6e6c12..17d5595140097 100644 --- a/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/interceptor/ClickHouseSkipInterceptor.java +++ b/plugins/clickhouse-jdbc/src/main/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/interceptor/ClickHouseSkipInterceptor.java @@ -10,11 +10,11 @@ public class ClickHouseSkipInterceptor implements AroundInterceptor { @Override public void before(Object target, Object[] args) { - + // ignore } @Override public void after(Object target, Object[] args, Object result, Throwable throwable) { - + // ignore } } diff --git a/plugins/clickhouse-jdbc/src/test/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseJdbcUrlParserTest.java b/plugins/clickhouse-jdbc/src/test/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseJdbcUrlParserTest.java new file mode 100644 index 0000000000000..224fef51b6bc7 --- /dev/null +++ b/plugins/clickhouse-jdbc/src/test/java/com/navercorp/pinpoint/plugin/jdbc/clickhouse/ClickHouseJdbcUrlParserTest.java @@ -0,0 +1,61 @@ +package com.navercorp.pinpoint.plugin.jdbc.clickhouse; + + +import com.navercorp.pinpoint.bootstrap.context.DatabaseInfo; +import com.navercorp.pinpoint.common.trace.ServiceType; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +/** + * @author intr3p1d + */ +public class ClickHouseJdbcUrlParserTest { + + private final Logger logger = LogManager.getLogger(getClass()); + private final ClickHouseJdbcUrlParser clickHouseJdbcUrlParser = new ClickHouseJdbcUrlParser(); + + private static final ServiceType SERVICE_TYPE = ClickHouseConstants.CLICK_HOUSE; + + @Test + public void clickHouseParse1() { + final String jdbcUrl = "jdbc:ch://(https://explorer@play.clickhouse.com:443)," + + "(https://demo:demo@github.demo.trial.altinity.cloud)" + + "/default?failover=1&load_balancing_policy=random"; + DatabaseInfo dbInfo = clickHouseJdbcUrlParser.parse(jdbcUrl); + Assertions.assertTrue(dbInfo.isParsingComplete()); + + Assertions.assertEquals(SERVICE_TYPE, dbInfo.getType()); + Assertions.assertEquals("(https://explorer@play.clickhouse.com:443)", dbInfo.getHost().get(0)); + Assertions.assertEquals("(https://demo:demo@github.demo.trial.altinity.cloud)", dbInfo.getHost().get(1)); + Assertions.assertEquals("default", dbInfo.getDatabaseId()); + Assertions.assertEquals("jdbc:ch://(https://explorer@play.clickhouse.com:443)," + + "(https://demo:demo@github.demo.trial.altinity.cloud)/default", dbInfo.getUrl()); + } + + @Test + public void clickHouseParse2() { + final String jdbcUrl = "jdbc:clickhouse://(https://explorer@play.clickhouse.com:443)," + + "(https://demo:demo@github.demo.trial.altinity.cloud)" + + "/default?failover=1&load_balancing_policy=random"; + DatabaseInfo dbInfo = clickHouseJdbcUrlParser.parse(jdbcUrl); + Assertions.assertTrue(dbInfo.isParsingComplete()); + + Assertions.assertEquals(SERVICE_TYPE, dbInfo.getType()); + Assertions.assertEquals("(https://explorer@play.clickhouse.com:443)", dbInfo.getHost().get(0)); + Assertions.assertEquals("(https://demo:demo@github.demo.trial.altinity.cloud)", dbInfo.getHost().get(1)); + Assertions.assertEquals("default", dbInfo.getDatabaseId()); + Assertions.assertEquals("jdbc:clickhouse://(https://explorer@play.clickhouse.com:443)," + + "(https://demo:demo@github.demo.trial.altinity.cloud)/default", dbInfo.getUrl()); + } + + @Test + public void parseFailTest1() { + DatabaseInfo dbInfo = clickHouseJdbcUrlParser.parse(null); + Assertions.assertFalse(dbInfo.isParsingComplete()); + + Assertions.assertEquals(ServiceType.UNKNOWN_DB, dbInfo.getType()); + } + +} \ No newline at end of file