Primeros pasos con snorql

Mar 16 2023

Bueno, la situación tampoco era tan diferente en Udaan y fue entonces cuando algunos de nosotros decidimos tomar el asunto en nuestras propias manos y crear una herramienta que ayudaría a abordar estos problemas de manera preventiva. Entra… ¿Qué es snorql? snorql es un proyecto de código abierto desarrollado en Udaan destinado a monitorear y diagnosticar problemas relacionados con la base de datos utilizando métricas de SQL.

¿Qué esperar de esta publicación?
Conoce tus herramientas
- Dropwizard
- Kotlin
- Maven
Configuración de su máquina local
Configurar su aplicación
- Crear un nuevo proyecto
- Agregar dependencias
- Construir y compilar
- Estructura del proyecto
- Código
Cree y ejecute la aplicación
Próximos pasos
preguntas frecuentes

Ingresar …

¿Qué es snorql?

snorql es un proyecto de código abierto desarrollado en Udaan destinado a monitorear y diagnosticar problemas relacionados con la base de datos utilizando métricas de SQL.

Brinda visibilidad sobre el rendimiento de cada base de datos, por lo que puede dejar de jugar a las adivinanzas y comenzar a optimizar sus bases de datos con facilidad. Y déjame decirte que esta visibilidad adicional ha cambiado las reglas del juego para nuestra organización. Ha aumentado la responsabilidad de cada equipo.

los resultados hablan por si mismos. Gracias a snorql,

Hemos visto un mayor rendimiento en más de 50 bases de datos.
Reducción de los costos de la nube en más del 60 %.
Mayor productividad del desarrollador
Tiempo de depuración reducido

Si mi preámbulo ha encendido su entusiasmo y está ansioso por comenzar, ha venido al lugar correcto. Pero en caso de que necesite más convicción, asegúrese de consultar el fantástico artículo titulado snorql: diagnosticar bases de datos como un jefe .

¿Qué esperar de esta publicación?

Snorql expone múltiples métricas como consultas activas, consultas bloqueadas, estadísticas de índice, crecimiento de la base de datos, etc. Lista completa aquí . Para esta publicación, recogeremos consultas activas. Active Queries es una herramienta valiosa para los usuarios de SQL Server que necesitan monitorear y optimizar el rendimiento de sus consultas en tiempo real.

En esta publicación, le mostraré cómo integrarse snorqlen una aplicación simple de Kotlin Dropwizard ( también puede replicar lo mismo en cualquier otro marco de Java ). Al final de este tutorial, su aplicación expondrá una API RESTful mediante la cual podrá averiguar las estadísticas de consultas en vivo para cualquier base de datos determinada.

Conoce tus herramientas

Para aquellos que ya están familiarizados con Kotlin, Dropwizard y Maven, no duden en omitir esta sección.

Dropwizard

Dropwizard es un marco ligero de Java para construir servicios web RESTful. Dropwizard recopila bibliotecas estables, como Jersey, Jackson y JDBI, en un paquete liviano. Para más detalles visitahttps://www.dropwizard.io/en/latest/.

Dato curioso: Dropwizard se inspiró en Ruby on Rails, un popular marco de aplicaciones web en el lenguaje de programación Ruby. Los creadores de Dropwizard querían brindar el mismo nivel de productividad y facilidad de uso al ecosistema de Java.

kotlin

Kotlin es un lenguaje de programación que admite programación funcional y orientada a objetos creado por JetBrains, una empresa de desarrollo de software con sede en Rusia. La sintaxis y los conceptos de Kotlin son similares a los de C#, Scala y Java. Para más detalles visitahttps://kotlinlang.org/

Un hecho divertido sobre Kotlin es que su nombre en realidad se deriva de una isla cerca de San Petersburgo, Rusia, llamada Isla Kotlin. Los creadores de Kotlin eligieron este nombre porque muchos de ellos viven en San Petersburgo o sus alrededores y la isla es un punto de referencia muy conocido en la zona.

Experto

Maven es una herramienta de administración y automatización de compilación para Java. Con Maven, es fácil definir la construcción del software y las dependencias.

Dato curioso: Maven fue creado por Jason van Zyl en 2002 mientras esperaba un vuelo en el aeropuerto O'Hare de Chicago.

Configuración de su máquina local

Encontrará muchos artículos y videos de YouTube sobre lo mismo, sin embargo, he adjuntado algunas referencias rápidas.

Instalación y configuración de maven —https://www.freecodecamp.org/news/how-to-get-started-with-maven-36851d8cfd96/
Instalación de Kotlin —https://www.oreilly.com/library/view/kotlin-cookbook/9781492046660/ch01.html
Instalación de IntelliJ —https://www.jetbrains.com/help/idea/installation-guide.html

Esta sección asume que ya ha configurado Maven, Kotlin e IntelliJ (o cualquier otro IDE con soporte para proyectos maven).

Creando un nuevo proyecto

Haga clic en Archivo -> Nuevo -> Proyecto -> Maven. Verá la siguiente ventana emergente

3. Su IDE abrirá el archivo pom.xml con el proyecto que tiene la siguiente estructura.

Agregar dependencias

Antes de comenzar con la implementación, debemos agregar las dependencias específicas requeridas para el proyecto en el pom.xmlarchivo. Hagámoslo juntos.

Comenzamos definiendo las versiones de Kotlin y Dropwizard en la etiqueta de propiedades.

<properties>
	  <maven.compiler.source>8</maven.compiler.source>
	  <maven.compiler.target>8</maven.compiler.target>
	  <kotlin.version>1.4.10</kotlin.version>
	  <kotlin.compiler.languageVersion>1.4</kotlin.compiler.languageVersion>
	  <kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget>
	  <dropwizard.version>2.0.13</dropwizard.version>
</properties>

<dependencies>
    <dependency>
        <groupId>io.dropwizard</groupId>
        <artifactId>dropwizard-core</artifactId>
        <version>${dropwizard.version}</version>
    </dependency>
    <dependency>
        <groupId>org.jetbrains.kotlin</groupId>
        <artifactId>kotlin-stdlib-jdk8</artifactId>
        <version>${kotlin.version}</version>
    </dependency>
</dependencies>

jdbi3

Necesitaremos esta dependencia para hacer conexiones a la base de datos. Estoy usando el jdbi3 aquí. Esto funcionará con cualquier versión de JDBC/JDBI.

Propiedades:

<jdbi.version>3.37.1</jdbi.version>

<dependency>
    <groupId>org.jdbi</groupId>
    <artifactId>jdbi3-core</artifactId>
    <version>${jdbi.version}</version>
</dependency>
<dependency>
    <groupId>org.jdbi</groupId>
    <artifactId>jdbi3-sqlobject</artifactId>
    <version>${jdbi.version}</version>
</dependency>
<dependency>
    <groupId>org.jdbi</groupId>
    <artifactId>jdbi3-kotlin-sqlobject</artifactId>
    <version>${jdbi.version}</version>
</dependency>

Tendremos que agregar esto para que la aplicación pueda conectarse con éxito a la base de datos del servidor SQL. Omitir esto le dará la infame java.sql.SQLException: No suitable driver foundexcepción. Aquí, usaré el snorql-extensionsmódulo que nos brinda métricas predefinidas correspondientes al servidor SQL, por lo tanto, vamos con este controlador.

Existe otro módulo, snorql-frameworkque es el marco básico de la herramienta subyacente. Exploraré eso en un próximo artículo donde sabremos cómo aprovechar este marco para diferentes bases de datos como Postgres, MySQL, etc.

Propiedades:

<mssql.version>9.2.1.jre8</mssql.version>

<dependency>
    <groupId>com.microsoft.sqlserver</groupId>
    <artifactId>mssql-jdbc</artifactId>
    <version>${mssql.version}</version>
</dependency>

¡Bueno, no puedo omitir esto!

Propiedades:

<snorql.version>0.5.6</snorql.version>

<dependency>
    <groupId>com.udaan.snorql</groupId>
    <artifactId>snorql-extensions</artifactId>
    <version>${snorql.version}</version>
</dependency>

Construir y compilar

El siguiente paso es especificar los directorios fuente en <sourceDirectory>y <testSourceDirectory>para compilar el código fuente. También configuraremos el complemento de Kotlin necesario para compilar nuestro código fuente.

Agregue el código pom.xmlcomo se muestra después de la sección de dependencias

<dependencies>
	.....
</dependencies>
<build>
    <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
    <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>
    <plugins>
        <plugin>
            <artifactId>kotlin-maven-plugin</artifactId>
            <groupId>org.jetbrains.kotlin</groupId>
            <version>${kotlin.version}</version>
            <executions>
                <execution>
                    <id>compile</id>
                    <goals>
                        <goal>compile</goal>
                    </goals>
                </execution>
                <execution>
                    <id>test-compile</id>
                    <goals>
                        <goal>test-compile</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Tan pronto como hagas esto, verás kotlin resaltado en rojo. Esto se debe a que la ruta no existe a partir de ahora, lo que nos lleva a la siguiente sección → estructura del proyecto

Estructura del proyecto

Esta es la estructura de mi proyecto. Puede ir con lo mismo para comenzar y luego personalizar según sus requisitos.

Código

Paso 1: Comenzamos creando un config.ymlarchivo dentro de src/main/resources. Podemos definir parámetros en este archivo de configuración que se deserializarán a una instancia de nuestra clase de configuración. Necesitamos agregar al menos un parámetro, de lo contrario, el marco Dropwizard arrojará un error durante la compilación. Sigamos adelante y agreguemos esto:

environment: local

package com.hawkeye.configuration

import com.fasterxml.jackson.annotation.JsonProperty
import io.dropwizard.Configuration


class AppConfig(@JsonProperty("environment") val environment: String): Configuration()

Paso 4: A continuación, creamos BootstrapSnorqlApplicationun archivo .kt dentro de la ruta src/main/kotlin/com/hawkeyey agregamos el siguiente código:

package com.hawkeye.core

import org.jdbi.v3.core.Jdbi
import org.jdbi.v3.core.kotlin.KotlinPlugin
import org.jdbi.v3.sqlobject.SqlObjectPlugin
import org.jdbi.v3.sqlobject.kotlin.KotlinSqlObjectPlugin

class JdbiFactory {

    /**
     * Return instance of JDBI with all plugins installed
     * @param dbName Name of the DB to connect
     */
    fun getInstance(dbName: String): Jdbi {
        return Jdbi.create(getConnectionStringByDatabaseName(dbName))
            .installPlugin(SqlObjectPlugin())
            .installPlugin(KotlinPlugin())
            .installPlugin(KotlinSqlObjectPlugin())
    }

    private fun getConnectionStringByDatabaseName(dbName: String): String {
        return when(dbName) {
            "db-prod" -> "jdbc:sqlserver://<server-name>:<port>;database=$dbName;user=<username>;password=<pwd>;encrypt=true;trustServerCertificate=false;hostNameInCertificate=*.database.windows.net;loginTimeout=30;"
            else -> ""
        }
    }
}

Paso 5: Ahora necesitamos implementar la Connectioninterfaz que snorql-frameworkexpone. Llamémoslo SqlServerConnectiony contendrá los métodos necesarios para snorqlinteractuar con la base de datos del usuario. Para esta publicación, implementar el run()método solo sería suficiente. Exploraremos los demás en una publicación de blog detallada por separado.

Cree un SqlServerConnection.ktarchivo en la ruta src/main/kotlin/com/hawkeye/corey agregue el siguiente código.

package com.hawkeye.core

import com.udaan.snorql.framework.metric.Connection
import com.udaan.snorql.framework.models.HistoricalDatabaseResult
import javax.inject.Inject

class SqlServerConnection @Inject constructor(private val jdbi3Factory: JdbiFactory) : Connection {
    override fun <T> run(databaseName:String, query: String, mapClass: Class<T>,params: Map<String, *>): List<T> {
        return if(params.isNotEmpty()){
            jdbi3Factory.getInstance(databaseName).withHandle<List<T>, Exception> { handle ->
                handle.createQuery(query).bindMap(params).mapTo(mapClass).toList()
            }
        } else{
            jdbi3Factory.getInstance(databaseName).withHandle<List<T>, Exception> { handle ->
                handle.createQuery(query).mapTo(mapClass).toList() as List<T>
            }
        }
    }

    override fun storeData(storageBucketId: String, columns: List<String>, rows: List<List<Any>>) {
        TODO("Not yet implemented")
    }

    override fun getHistoricalData(
        storageBucketId: String,
        metricId: String,
        databaseName: String,
        columns: List<String>,
        paginationParams: Map<String, *>,
        params: Map<String, *>
    ): HistoricalDatabaseResult {
        TODO("Not yet implemented")
    }
}

snorql expone muchas métricas de SQL útiles que se pueden integrar y usar con su aplicación. Para esta publicación, seleccionaremos la métrica que será más relevante para cualquiera que haya usado alguna vez una base de datos: Active Queries.

Consultas activas, también conocidas como estadísticas de consultas en vivo, es una característica de SQL Server que permite a los usuarios monitorear el progreso de sus consultas en tiempo real. Proporciona información sobre el estado de una consulta, como el porcentaje de finalización, el tiempo transcurrido y el tiempo restante estimado, así como el plan de ejecución utilizado por SQL Server para procesar la consulta.

Para eso, cree un SnorqlMetricsResource.ktarchivo dentro src/main/kotlin/com/hawkeye/resourcesy agregue el siguiente código.

package com.hawkeye.resources

import com.fasterxml.jackson.annotation.JsonProperty
import com.udaan.snorql.extensions.performance.PerformanceEnums
import com.udaan.snorql.extensions.performance.models.ActiveQueryInput
import com.udaan.snorql.extensions.performance.models.ActiveQueryResult
import com.udaan.snorql.framework.metric.SqlMetricManager
import com.udaan.snorql.framework.models.IMetricRecommendation
import com.udaan.snorql.framework.models.MetricPeriod
import javax.ws.rs.Consumes
import javax.ws.rs.POST
import javax.ws.rs.Path
import javax.ws.rs.Produces
import javax.ws.rs.container.AsyncResponse
import javax.ws.rs.container.Suspended
import javax.ws.rs.core.MediaType
import javax.ws.rs.core.Response

@Path("/snorql")
class SnorqlMetricsResource {
    /*
    * Fetches list of active-queries metric for a [activeQueryMetricInput]
    */
    @POST
    @Path("activeQueries")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    fun getActiveQueryMetric(
        input: Input,
        @Suspended asyncResponse: AsyncResponse
    ) {

        val activeQueryInput = ActiveQueryInput(
            databaseName = input.databaseName,
            metricPeriod = input.metricPeriod,
            metricId = input.metricId
        )
        try {
            val response = SqlMetricManager.getMetric<ActiveQueryInput, ActiveQueryResult, IMetricRecommendation>(
                PerformanceEnums.ACTIVE_QUERIES.getId(),
                activeQueryInput
            )
            asyncResponse.resume(Response.ok(response).build())

        } catch (e: Exception) {
            println("Something went wrong. Error : ${e.message as String}")
            Response.status(500).entity(e.message as String).build()
        }
    }
}

data class Input (
    @JsonProperty("metricId")
    val metricId: String = PerformanceEnums.ACTIVE_QUERIES.getId(),
    @JsonProperty("metricPeriod")
    val metricPeriod: MetricPeriod,
    @JsonProperty("databaseName")
    val databaseName: String
)

package com.hawkeye

import com.google.inject.AbstractModule
import com.google.inject.Guice
import com.hawkeye.configuration.AppConfig
import com.hawkeye.core.SqlServerConnection
import com.hawkeye.resources.SnorqlMetricsResource
import com.udaan.snorql.extensions.SQLCommonMetrics
import com.udaan.snorql.framework.metric.SqlMetricManager
import io.dropwizard.Application
import io.dropwizard.setup.Environment

class HawkeyeApplication: Application<AppConfig>() {
    companion object {
        @JvmStatic fun main(args: Array<String>) = HawkeyeApplication().run(*args)
    }

    override fun run(appConfig: AppConfig, environment: Environment) {
        environment.jersey().register(SnorqlMetricsResource::class.java)
        registerSQLMetrics()
    }

    private fun registerSQLMetrics() {
        val sqlServerConnectionInstance =
            Guice.createInjector(SqlClientModule()).getInstance(SqlServerConnection::class.java)
        SqlMetricManager.setConnection(sqlServerConnectionInstance)
        SQLCommonMetrics.initialize()
    }
}

class SqlClientModule : AbstractModule()

Cree y ejecute la aplicación

Estamos listos para ejecutar nuestroHawkeyeApplication

Para hacer eso, agregue la configuración como se muestra a continuación:

Tenga en cuenta que hemos agregado server src/main/resources/config.ymlen los argumentos del programa. Esto le dice a la aplicación Dropwizard que se ejecute como un servidor y en la ubicación del archivo de configuración proporcionado.

Si todo va bien deberías ver algo como esto en la terminal. Si no es así y le gritan algunos errores, no se preocupe, también lo tengo cubierto. Dirígete a la sección de preguntas frecuentes y comprueba los errores/resoluciones a los que me enfrenté.

Dirígete a Postman o cualquier otra herramienta similar y prueba la API. Haga clic en Importar -> Texto sin procesar -> Copie y pegue la llamada curl que se proporciona a continuación -> Haga clic en Continuar -> Haga clic en Enviar

curl --location --request POST 'localhost:8080/snorql/activeQueries' \
--header 'Content-Type: application/json' \
--data-raw '{
    "databaseName": "db-prod",
    "metricId": "performance_activeQueries",
    "metricPeriod": "REAL_TIME",
    "recommendationRequired": true
}'

Aquí, hemos consultado para ver todas las consultas activas para la base de datos db-prod. La respuesta se divide en 3 partes:

entrada métrica

Esto devuelve la entrada proporcionada por el usuario con valores predeterminados en campos opcionales.

"metricInput": {
    "from": null,
    "to": null,
    "recommendationRequired": false,
    "metricId": "performance_activeQueries",
    "metricPeriod": "REAL_TIME",
    "databaseName": "db-prod"
  }

Esto le brinda la lista de consultas que se ejecutan en este momento en su base de datos junto con todos los parámetros relevantes asociados con ellas. Esto podría ser útil en los siguientes escenarios:

Cuando intenta depurar el aumento de latencia en su base de datos y desea verificar si hay consultas de ejecución prolongada que han estado acaparando su CPU mirando elapsedTime. Estas consultas de ejecución prolongada pueden deberse a una variedad de problemas, como planes de consulta ineficientes, indexación subóptima o consultas mal escritas. Además de esto, también podemos usar esto para analizar la distribución de los tiempos de ejecución de consultas en la base de datos y tomar medidas proactivas para evitar problemas antes de que ocurran.
Cuando se encuentra en un estado en el que la base de datos parece bloqueada o un proceso no está en curso, verificar el bloqueo de la base de datos tiene mucho sentido y puede averiguar el identificador de sesión exacto que bloquea esta consulta con la ayuda de blockedBy.
El openTransactionCountparámetro se utiliza para monitorear el número de transacciones abiertas en una base de datos en un momento dado. Si este recuento es constantemente alto, puede indicar que hay transacciones que no se están confirmando o revirtiendo de manera oportuna. Esto puede dar lugar a problemas como la contención de recursos, el aumento de los bloqueos y los interbloqueos, que pueden afectar negativamente al rendimiento y la disponibilidad de la base de datos. Al usar el openTransactionCountparámetro junto con otras métricas de rendimiento, como el tiempo de ejecución de la consulta y el tiempo de espera de la consulta, podemos identificar correctamente las consultas que requieren nuestra atención.

"metricOutput": {
    "result": {
	"queryList": [
	    {
		"sessionId": 627,
		"status": "running",
		"blockedBy": 0,
		"waitType": null,
		"waitResource": "",
		"percentComplete": 0,
		"waitTime": "00:00:00",
		"cpuTime": 2,
		"logicalReads": 19,
		"reads": 0,
		"writes": 0,
		"elapsedTime": "0d 00:00:00",
		"queryText": "<?query --  \\n\\nSELECT DISTINCT ffi.shipment_group_id, so.extra_data, so.order_type, cac.amount_in_paisa as consumed_amount_in_paisa FROM fulfillment_line_items ffi JOIN seller_order_line ol on ol.order_line_id = ffi.order_line_id JOIN seller_order so on so.order_id = ol.seller_order_id LEFT OUTER JOIN collected_advance_consumable cac on cac.consumed_for = ffi.shipment_group_id WHERE ffi.shipment_group_id in (@P0)\\n\\n--?>",
		"storedProc": "",
		"command": "SELECT",
		"loginName": "udaan",
		"hostName": "order-processing-daemons-6fdfb74677-86xtx",
		"programName": "order-processing-daemons-6fdfb74677-86xtx/order-mgmt",
		"hostProcessId": 0,
		"lastRequestEndTime": "2023-02-24 10:36:18.283",
		"loginTime": "2023-02-24 10:32:52.12",
		"openTransactionCount": 0
	     }
	 ]
    },
    "recommendation": null
}

Esta sección nos brinda detalles sobre las consultas utilizadas por snorql para generar el resultado anterior. Esto también viene con una breve descripción y una referencia rápida a la documentación oficial de Microsoft.

Los supportsHistorical& minimumRepeatIntervalson parte de una función en la que snorql nos ayuda a registrar y almacenar el conjunto de resultados de una consulta en un intervalo determinado, lo que nos permite revisar datos anteriores. Esto ayudará en las autopsias, la clasificación de problemas y la búsqueda de anomalías. Esta característica requiere una publicación detallada separada propia.

"metadata": {
    "underlyingQueries": [
        "SELECT sessionId=s.session_id\\n ,status=r.STATUS\\n ,blockedBy=r.blocking_session_id\\n ,waitType=r.wait_type\\n, waitResource=r.wait_resource\\n, waitTime=CONVERT(VARCHAR, DATEADD(ms, r.wait_time, 0), 8)\\n, cpuTime=r.cpu_time\\n, logicalReads=r.logical_reads\\n, r.reads\\n ,r.writes,\\n r.percent_complete as percentComplete\\n,elapsedTime=CONVERT(varchar, (r.total_elapsed_time/1000 / 86400))+ 'd ' +\\n CONVERT(VARCHAR, DATEADD(ms, r.total_elapsed_time, 0), 8)\\n ,queryText=CAST((\\n         '<?query --  ' + CHAR(13) + CHAR(13) + Substring(st.TEXT, (r.statement_start_offset / 2) + 1, (\\n  (\\n CASE r.statement_end_offset\\n WHEN - 1\\n THEN Datalength(st.TEXT)\\n  ELSE r.statement_end_offset\\n END - r.statement_start_offset\\n) / 2\\n) + 1) + CHAR(13) + CHAR(13) + '--?>'\\n ) AS XML)\\n, storedProc=COALESCE(\\n QUOTENAME(DB_NAME(st.dbid)) + N'.' + \\n QUOTENAME(OBJECT_SCHEMA_NAME(st.objectid, st.dbid)) + N'.' +\\n QUOTENAME(OBJECT_NAME(st.objectid, st.dbid)), ''\\n)\\n  --,qp.query_plan AS 'xml_plan'  -- uncomment (1) if you want to see plan\\n, r.command\\n ,loginName=s.login_name\\n ,hostName=s.host_name\\n ,programName=s.program_name\\n ,hostProcessId=s.host_process_id\\n ,lastRequestEndTime=s.last_request_end_time\\n ,loginTime=s.login_time\\n ,openTransactionCount=r.open_transaction_count\\n FROM sys.dm_exec_sessions AS s\\n INNER JOIN sys.dm_exec_requests AS r ON r.session_id = s.session_id\\n CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) AS st\\n --OUTER APPLY sys.dm_exec_query_plan(r.plan_handle) AS qp -- uncomment (2) if you want to see plan \\n ORDER BY r.blocking_session_id"
    ],
    "referenceDocumentation": [],
    "description": "",
    "supportsHistorical": true,
    "minimumRepeatInterval": "10"
}

Si desea ver el código completo, visite aquí enhttps://github.com/lakshmi-udaan/hawkeye

Próximos pasos

¿Lo que hicimos?

Habiendo obtenido los datos requeridos, nos dispusimos a crear una poderosa herramienta de visualización. Con este fin, aumentamos las API con una capa de interfaz de usuario fácil de usar y producimos el Tablero SQL, que proporciona una vista panorámica completa de todas las bases de datos y vistas detalladas y granulares de las individuales. Los desarrolladores de nuestra organización confían mucho en él para tareas relacionadas con SQL. Lamentablemente, actualmente no es de código abierto, pero si está interesado, estaré feliz de discutir más. Aquí hay un adelanto del mismo.

Tablero de monitoreo y diagnóstico de SQL en udaan creado con snorql

¿Lo que puedes hacer?

Ahora que sabe cómo usar snorql, es solo cuestión de tiempo antes de que desbloquee todo su potencial y comience a aumentar exponencialmente el rendimiento de su base de datos.

Puede encontrar la lista de todas las métricas disponibles aquí . Puede obtener estas métricas simplemente modificando los parámetros que se pasan dentro SqlMetricManager.getMetric()como lo hicimos al crear el punto final de la API para Consultas activas aquí .

En mi próxima publicación, profundizaremos en cómo podemos usar algunas de estas métricas para mejorar la productividad de su base de datos a 10 veces.

¡Gracias por leer!

preguntas frecuentes

No se pudo encontrar el artefacto com.udaan.snorql:snorql-framework:pom:0.5.6 en xyz
Solución: haga un archivo mvn clean install. Esto limpiará lo que se haya creado a partir de la compilación anterior, luego compilará su proyecto y agregará los archivos jar a su repositorio maven local (.m2\repository)
Si se le solicita este error Solución: debe cargar . Te has perdido de agregarjava.sql.SQLException: No suitable driver found
jdbc drivermssql-jdbc

https://udaan-com.github.io/snorql/

https:///engineering-udaan/snorql-diagnosing-databases-like-a-boss-54f2e8fbf57a