Iniziare con snorql

Mar 16 2023

Bene, la situazione non era molto diversa neanche a Udaan ed è stato allora che alcuni di noi hanno deciso di prendere in mano la situazione e creare uno strumento che aiutasse ad affrontare preventivamente questi problemi. Entra... Cos'è snorql? snorql è un progetto open source sviluppato presso Udaan volto a monitorare e diagnosticare i problemi relativi al database utilizzando le metriche SQL.

Cosa aspettarsi da questo post?
Conosci i tuoi strumenti
- Dropwizard
- Kotlin
- Maven
Configurazione della macchina locale
Configurazione dell'applicazione
- Creazione di un nuovo progetto
- Aggiunta di dipendenze
- Compilazione e compilazione
- Struttura del progetto
- Codice
Crea ed esegui l'applicazione
Prossimi passi
Domande frequenti

Accedere …

Cos'è lo snorql?

snorql è un progetto open source sviluppato presso Udaan volto a monitorare e diagnosticare i problemi relativi al database utilizzando le metriche SQL.

Fornisce visibilità sulle prestazioni di ogni database, così puoi smettere di giocare a indovinare e iniziare a ottimizzare i tuoi database con facilità. E lascia che te lo dica, questa maggiore visibilità è stata un punto di svolta per la nostra organizzazione. Ha aumentato la responsabilità di ogni squadra.

I risultati parlano da soli. Grazie a snorql,

Abbiamo visto un aumento delle prestazioni in oltre 50 database.
Riduzione dei costi del cloud di oltre il 60%.
Aumento della produttività degli sviluppatori
Tempo di debug ridotto

Se il mio preambolo ha acceso la tua eccitazione e non vedi l'ora di iniziare, sei nel posto giusto. Ma nel caso abbiate bisogno di ulteriori convinzioni, assicuratevi di dare un'occhiata al fantastico articolo intitolato snorql — diagnosticare i database come un boss .

Cosa aspettarsi da questo post?

Snorql espone più metriche come Query attive, Query bloccate, Statistiche indice, Crescita database, ecc... elenco completo qui . Per questo post, raccoglieremo le query attive. Active Query è uno strumento prezioso per gli utenti di SQL Server che hanno bisogno di monitorare e ottimizzare le prestazioni delle loro query in tempo reale.

In questo post, ti mostrerò come integrarti snorqlin una semplice applicazione Kotlin Dropwizard ( puoi replicare lo stesso anche in qualsiasi altro framework Java ). Alla fine di questo tutorial, la tua applicazione esporrà un'API RESTful utilizzando la quale sarai in grado di scoprire le statistiche delle query in tempo reale per un determinato database.

Conosci i tuoi strumenti

Per coloro che hanno già familiarità con Kotlin, Dropwizard e Maven, sentiti libero di saltare questa sezione.

Dropwizard

Dropwizard è un framework Java leggero per la creazione di servizi Web RESTful. Dropwizard raccoglie librerie stabili, come Jersey, Jackson e JDBI, in un pacchetto leggero. Per maggiori dettagli visitahttps://www.dropwizard.io/en/latest/.

Curiosità: Dropwizard è stato ispirato da Ruby on Rails, un popolare framework per applicazioni web nel linguaggio di programmazione Ruby. I creatori di Dropwizard volevano portare lo stesso livello di produttività e facilità d'uso nell'ecosistema Java.

Kotlin

Kotlin è un linguaggio di programmazione che supporta la programmazione funzionale e orientata agli oggetti creato da JetBrains, una società di sviluppo software con sede in Russia. La sintassi e i concetti di Kotlin sono simili a C#, Scala e Java. Per maggiori dettagli visitahttps://kotlinlang.org/

Un fatto divertente su Kotlin è che il suo nome deriva in realtà da un'isola vicino a San Pietroburgo, in Russia, chiamata Kotlin Island. I creatori di Kotlin hanno scelto questo nome perché molti di loro vivono a San Pietroburgo o nei dintorni e l'isola è un noto punto di riferimento della zona.

Esperto di

Maven è uno strumento di automazione e gestione della build per Java. Con Maven è facile definire la costruzione del software e le dipendenze.

Curiosità: Maven è stato creato da Jason van Zyl nel 2002 mentre aspettava un volo all'aeroporto O'Hare di Chicago.

Configurazione della macchina locale

Troverai molti articoli e video di YouTube per lo stesso, tuttavia, ho allegato alcuni riferimenti rapidi

Installazione e configurazione di Maven —https://www.freecodecamp.org/news/how-to-get-started-with-maven-36851d8cfd96/
Installazione di Kotlin —https://www.oreilly.com/library/view/kotlin-cookbook/9781492046660/ch01.html
Installazione di IntelliJ —https://www.jetbrains.com/help/idea/installation-guide.html

Questa sezione presuppone che tu abbia già configurato Maven, Kotlin e IntelliJ (o qualsiasi altro IDE con supporto per progetti Maven).

Creazione di un nuovo progetto

Fare clic su File -> Nuovo -> Progetto -> Maven. Vedrai il seguente popup

3. Il tuo IDE aprirà il file pom.xml con il progetto con la seguente struttura.

Aggiunta di dipendenze

Prima di iniziare con l'implementazione, dobbiamo aggiungere nel pom.xmlfile le dipendenze specifiche richieste per il progetto. Facciamolo assieme.

Iniziamo definendo le versioni di Kotlin e Dropwizard nel tag delle proprietà.

<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

Avremo bisogno di questa dipendenza per effettuare connessioni al database. Sto usando il jdbi3 qui. Funzionerà con qualsiasi versione di JDBC/JDBI.

Proprietà:

<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>

Dovremo aggiungerlo affinché l'applicazione sia in grado di connettersi correttamente al database del server SQL. Omettere questo ti darà la famigerata java.sql.SQLException: No suitable driver foundeccezione. Qui, userò il snorql-extensionsmodulo che ci fornisce metriche predefinite corrispondenti al server SQL, quindi stiamo andando con questo driver.

Esiste un altro modulo, snorql-frameworkche è la struttura di base dello strumento sottostante. Lo esplorerò in un prossimo articolo in cui sapremo come sfruttare questo framework per diversi database come Postgres, MySQL, ecc...

Proprietà:

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

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

Beh, non posso ometterlo!

Proprietà:

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

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

Costruisci e compila

Il passaggio successivo consiste nello specificare le directory di origine in <sourceDirectory>e in <testSourceDirectory>per compilare il codice sorgente. Configureremo anche il plugin Kotlin necessario per compilare il nostro codice sorgente.

Aggiungi il codice pom.xmlcome mostrato dopo la sezione delle dipendenze

<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>

Non appena lo fai, vedrai kotlin evidenziato in rosso. Questo perché il percorso non esiste al momento, il che ci porta alla sezione successiva → struttura del progetto

Struttura del progetto

Questa è la struttura del mio progetto. Puoi andare con lo stesso per iniziare e successivamente personalizzare in base alle tue esigenze.

Codice

Passaggio 1: iniziamo creando un config.ymlfile all'interno di src/main/resources. Possiamo definire parametri in questo file di configurazione che verranno deserializzati in un'istanza della nostra classe di configurazione. Dobbiamo aggiungere almeno un parametro, altrimenti il framework Dropwizard genererà un errore durante la compilazione. Andiamo avanti e aggiungiamo questo:

environment: local

package com.hawkeye.configuration

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


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

Passaggio 4: Successivamente, creiamo BootstrapSnorqlApplicationil file .kt all'interno del percorso src/main/kotlin/com/hawkeyee aggiungiamo il seguente codice:

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 -> ""
        }
    }
}

Passaggio 5: ora dobbiamo implementare l' Connectioninterfaccia che snorql-frameworkespone. Chiamiamolo SqlServerConnectione conterrà i metodi richiesti per snorqlinteragire con il database dell'utente. Per questo post run()sarebbe sufficiente implementare il metodo da solo. Esploreremo gli altri in un post di blog dettagliato separato.

Crea un SqlServerConnection.ktfile nel percorso src/main/kotlin/com/hawkeye/coree aggiungi il codice seguente.

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 espone molte utili metriche SQL che possono essere integrate e utilizzate con la tua applicazione. Per questo post, sceglieremo la metrica più rilevante per chiunque abbia mai utilizzato un database: Active Queries.

Le query attive, note anche come statistiche delle query in tempo reale, sono una funzionalità di SQL Server che consente agli utenti di monitorare lo stato di avanzamento delle loro query in tempo reale. Fornisce informazioni sullo stato di una query, ad esempio la percentuale di completamento, il tempo trascorso e il tempo rimanente stimato, nonché il piano di esecuzione utilizzato da SQL Server per elaborare la query.

Per questo, crea un SnorqlMetricsResource.ktfile all'interno src/main/kotlin/com/hawkeye/resourcese aggiungi il codice seguente.

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()

Crea ed esegui l'applicazione

Siamo pronti per eseguire il nostroHawkeyeApplication

Per farlo, aggiungi la configurazione come mostrato di seguito:

Si noti che abbiamo aggiunto server src/main/resources/config.ymlgli argomenti del programma. Ciò indica all'app Dropwizard di essere eseguita come server e rispetto alla posizione del file di configurazione fornito.

Se tutto va bene dovresti vedere qualcosa di simile nel terminale. In caso contrario e vieni sgridato con alcuni errori, non preoccuparti, ti ho coperto anche per quello. Vai alla sezione FAQ e controlla gli errori/le soluzioni che ho riscontrato.

Vai su Postman o qualsiasi altro strumento simile e testa l'API. Fare clic su Importa -> Testo non elaborato -> Copia incolla la chiamata curl indicata di seguito -> Fare clic su Continua -> Fare clic su Invia

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
}'

Qui, abbiamo interrogato per vedere tutte le query attive per il database db-prod. La risposta è suddivisa in 3 parti:

metricInput

Questo restituisce l'input fornito dall'utente con i valori predefiniti nei campi facoltativi.

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

Questo ti dà l'elenco delle query in esecuzione in questo momento nel tuo database insieme a tutti i parametri rilevanti ad esse associati. Questo potrebbe essere utile nei seguenti scenari:

Quando stai provando a eseguire il debug della maggiore latenza sul tuo database e vuoi verificare se ci sono query di lunga durata che hanno bloccato la tua CPU guardando elapsedTime. Queste query a esecuzione prolungata possono essere causate da una serie di problemi, ad esempio piani di query inefficienti, indicizzazione non ottimale o query scritte in modo non corretto. Oltre a questo, possiamo anche usarlo per analizzare la distribuzione dei tempi di esecuzione delle query nel database e adottare misure proattive per prevenire i problemi prima che si verifichino.
Quando sei in uno stato in cui il database sembra bloccato o un processo non sta procedendo, il controllo del blocco del database ha molto senso e puoi capire l'esatto ID di sessione che blocca questa query con l'aiuto di blockedBy.
Il openTransactionCountparametro viene utilizzato per monitorare il numero di transazioni aperte in un database in un dato momento. Se questo conteggio è costantemente elevato, potrebbe indicare che sono presenti transazioni di cui non è stato eseguito il commit o il rollback in modo tempestivo. Ciò può portare a problemi come conflitto di risorse, aumento dei blocchi e deadlock, che possono influire negativamente sulle prestazioni e sulla disponibilità del database. Utilizzando il openTransactionCountparametro insieme ad altre metriche delle prestazioni, come il tempo di esecuzione della query e il tempo di attesa della query, possiamo identificare correttamente le query che richiedono la nostra attenzione.

"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
}

Questa sezione fornisce dettagli sulle query utilizzate da snorql per generare l'output di cui sopra. Questo include anche una breve descrizione e un rapido riferimento alla documentazione ufficiale di Microsoft.

Gli supportsHistorical& minimumRepeatIntervalfanno parte di una funzionalità in cui snorql ci aiuta a registrare e archiviare il set di risultati di un output di query a un dato intervallo, consentendoci di rivisitare i dati passati. Ciò aiuterà nell'autopsia, nella valutazione dei problemi e nella ricerca di anomalie. Questa funzione richiede un proprio post dettagliato separato.

"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"
}

Se vuoi controllare l'intero codice, visita qui ahttps://github.com/lakshmi-udaan/hawkeye

Prossimi passi

Cosa abbiamo fatto?

Dopo aver ottenuto i dati richiesti, abbiamo deciso di creare un potente strumento di visualizzazione. A tal fine, abbiamo potenziato le API con un livello di interfaccia utente intuitivo e prodotto SQL Dashboard, che fornisce sia una vista panoramica completa di tutti i database sia viste dettagliate e granulari di quelli individuali. Gli sviluppatori della nostra organizzazione fanno molto affidamento su di esso per le attività relative a SQL. Purtroppo, al momento non è open source, ma se sei interessato, sono felice di discutere ulteriormente. Ecco un'anteprima dello stesso.

Dashboard di diagnostica e monitoraggio SQL presso udaan creato utilizzando snorql

Cosa puoi fare?

Ora che sai come usare snorql, è solo una questione di tempo prima che tu sblocchi il suo pieno potenziale e inizi a migliorare le prestazioni del tuo database in modo esponenziale.

Puoi trovare l'elenco di tutte le metriche disponibili qui . Puoi ottenere queste metriche semplicemente modificando i parametri passati all'interno SqlMetricManager.getMetric()come abbiamo fatto durante la creazione dell'endpoint API per le query attive qui .

Nel mio prossimo post, approfondiremo il modo in cui possiamo utilizzare alcune di queste metriche per aumentare la produttività del database fino a 10 volte.

Grazie per aver letto!

Domande frequenti

Impossibile trovare l'artefatto com.udaan.snorql:snorql-framework:pom:0.5.6 in xyz
Soluzione: eseguire un file mvn clean install. Questo pulirà tutto ciò che è stato creato dalla build precedente, quindi costruirà il tuo progetto e aggiungerà i jar al tuo repository maven locale (.m2\repository)
Se ti viene richiesto con questo errore Soluzione: devi caricare . Ti sei perso l'aggiuntajava.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