Débuter avec snorql

Mar 16 2023

Eh bien, la situation n'était pas si différente non plus à Udaan et c'est à ce moment-là que certains d'entre nous ont décidé de prendre les choses en main et de créer un outil qui aiderait à résoudre ces problèmes de manière préventive. Entrez… Qu'est-ce que snorql ? snorql est un projet open source développé à Udaan visant à surveiller et diagnostiquer les problèmes liés aux bases de données à l'aide de métriques SQL.

Qu'attendre de ce post ?
Connaître ses outils
- Dropwizard
- Kotlin
- Maven
Configuration de votre machine locale
Configuration de votre application
- Création d'un nouveau projet
- Ajout de dépendances
- Build & Compile
- Structure du projet
- Code
Créer et exécuter l'application
Prochaines étapes
FAQ

Entrer …

Qu'est-ce que snorql ?

snorql est un projet open source développé à Udaan visant à surveiller et diagnostiquer les problèmes liés aux bases de données à l'aide de métriques SQL.

Il offre une visibilité sur les performances de chaque base de données, ce qui vous permet d'arrêter de jouer aux devinettes et de commencer à optimiser vos bases de données en toute simplicité. Et laissez-moi vous dire que cette visibilité supplémentaire a changé la donne pour notre organisation. Cela a renforcé la responsabilisation de chaque équipe.

Les résultats parlent d'eux-mêmes. Merci à snorql,

Nous avons constaté une augmentation des performances dans plus de 50 bases de données.
Réduction des coûts du cloud de plus de 60 %.
Augmentation de la productivité des développeurs
Temps de débogage réduit

Si mon préambule a suscité votre enthousiasme et que vous avez hâte de commencer, vous êtes au bon endroit. Mais au cas où vous auriez besoin d'être davantage convaincu, n'oubliez pas de consulter le fantastique article intitulé snorql - diagnostiquer les bases de données comme un patron .

Qu'attendre de ce post ?

Snorql expose plusieurs métriques comme les requêtes actives, les requêtes bloquées, les statistiques d'index, la croissance de la base de données, etc… liste complète ici . Pour cet article, nous reprendrons les requêtes actives. Active Queries est un outil précieux pour les utilisateurs de SQL Server qui ont besoin de surveiller et d'optimiser les performances de leurs requêtes en temps réel.

Dans cet article, je vais vous montrer comment intégrer snorqlune simple application Kotlin Dropwizard ( vous pouvez également répliquer la même chose dans n'importe quel autre framework Java ). À la fin de ce didacticiel, votre application exposera une API RESTful à l'aide de laquelle vous pourrez connaître les statistiques de requête en direct pour une base de données donnée.

Connaissez vos outils

Pour ceux qui connaissent déjà Kotlin, Dropwizard et Maven, n'hésitez pas à ignorer cette section.

Dropwizard

Dropwizard est un framework Java léger pour la création de services Web RESTful. Dropwizard rassemble des bibliothèques stables, telles que Jersey, Jackson et JDBI, dans un package léger. Pour plus de détails visitezhttps://www.dropwizard.io/en/latest/.

Fait amusant : Dropwizard a été inspiré par Ruby on Rails, un cadre d'application Web populaire dans le langage de programmation Ruby. Les créateurs de Dropwizard ont voulu apporter le même niveau de productivité et de facilité d'utilisation à l'écosystème Java.

Kotlin

Kotlin est un langage de programmation qui prend en charge la programmation fonctionnelle et orientée objet créé par JetBrains, une société de développement de logiciels basée en Russie. La syntaxe et les concepts de Kotlin sont similaires à C#, Scala et Java. Pour plus de détails visitezhttps://kotlinlang.org/

Un fait amusant à propos de Kotlin est que son nom est en fait dérivé d'une île près de Saint-Pétersbourg, en Russie, appelée l'île de Kotlin. Les créateurs de Kotlin ont choisi ce nom car beaucoup d'entre eux vivent à Saint-Pétersbourg ou dans ses environs et l'île est un point de repère bien connu dans la région.

Maven

Maven est un outil d'automatisation et de gestion de build pour Java. Avec Maven, il est facile de définir la construction du logiciel et les dépendances.

Fait amusant : Maven a été créé par Jason van Zyl en 2002 alors qu'il attendait un vol à l'aéroport O'Hare de Chicago.

Configuration de votre machine locale

Vous trouverez de nombreux articles et vidéos YouTube pour la même chose, cependant, j'ai joint quelques références rapides

Installation et configuration de maven —https://www.freecodecamp.org/news/how-to-get-started-with-maven-36851d8cfd96/
Installation de Kotlin —https://www.oreilly.com/library/view/kotlin-cookbook/9781492046660/ch01.html
Installation d'IntelliJ —https://www.jetbrains.com/help/idea/installation-guide.html

Cette section suppose que vous avez déjà configuré Maven, Kotlin et IntelliJ (ou tout autre IDE prenant en charge les projets maven).

Créer un nouveau projet

Cliquez sur Fichier -> Nouveau -> Projet -> Maven. Vous verrez le popup suivant

3. Votre IDE ouvrira le fichier pom.xml avec le projet ayant la structure suivante.

Ajout de dépendances

Avant de commencer l'implémentation, nous devons ajouter les dépendances spécifiques requises pour le projet dans le pom.xmlfichier. Faisons le ensemble.

Nous commençons par définir les versions de Kotlin & Dropwizard dans la balise properties.

<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

Nous aurons besoin de cette dépendance pour établir des connexions à la base de données. J'utilise le jdbi3 ici. Cela fonctionnera avec n'importe quelle version de JDBC/JDBI.

Propriétés:

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

Nous devrons l'ajouter pour que l'application puisse se connecter avec succès à la base de données du serveur SQL. Omettre cela vous donnera la tristement célèbre java.sql.SQLException: No suitable driver foundexception. Ici, je vais utiliser le snorql-extensionsmodule qui nous donne des métriques prédéfinies correspondant au serveur SQL, donc nous allons avec ce pilote.

Il existe un autre module, snorql-frameworkqui est le cadre de base de l'outil sous-jacent. J'explorerai cela dans un prochain article où nous saurons comment tirer parti de ce framework pour différentes bases de données comme Postgres, MySQL, etc…

Propriétés:

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

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

Eh bien, ne peut pas omettre cela!

Propriétés:

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

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

Construire et compiler

L'étape suivante consiste à spécifier les répertoires source dans <sourceDirectory>et dans <testSourceDirectory>afin de compiler le code source. Nous allons également configurer le plugin Kotlin requis pour compiler notre code source.

Ajoutez le code à pom.xmlcomme indiqué après la section des dépendances

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

Dès que vous faites cela, vous verrez kotlin surligné en rouge. En effet, le chemin n'existe pas pour le moment, ce qui nous amène à la section suivante → structure du projet

Structure du projet

Ceci est la structure de mon projet. Vous pouvez utiliser la même chose pour commencer et ensuite personnaliser en fonction de vos besoins.

Code

Étape 1 : Nous commençons par créer un config.ymlfichier à l'intérieur src/main/resourcesde . Nous pouvons définir des paramètres dans ce fichier de configuration qui seront désérialisés en une instance de notre classe de configuration. Nous devons ajouter au moins un paramètre, sinon le framework Dropwizard renverra une erreur lors de la compilation. Allons-y et ajoutons ceci :

environment: local

package com.hawkeye.configuration

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


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

Étape 4 : Ensuite, nous créons BootstrapSnorqlApplicationle fichier .kt dans le chemin src/main/kotlin/com/hawkeyeet ajoutons le code suivant :

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

Étape 5 : Nous devons maintenant implémenter l' Connectioninterface qui snorql-frameworkexpose. Appelons-le SqlServerConnectionet il contiendra les méthodes requises pour snorqlinteragir avec la base de données de l'utilisateur. Pour ce poste, la mise en œuvre de la run()méthode seule suffirait. Nous explorerons les autres dans un article de blog détaillé séparé.

Créez un SqlServerConnection.ktfichier dans le chemin src/main/kotlin/com/hawkeye/coreet ajoutez le code ci-dessous.

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 expose de nombreuses métriques SQL utiles qui peuvent être intégrées et utilisées avec votre application. Pour cet article, nous choisirons la métrique la plus pertinente pour quiconque a déjà utilisé une base de données — Active Queries.

Les requêtes actives, également appelées statistiques de requête en direct, sont une fonctionnalité de SQL Server qui permet aux utilisateurs de surveiller la progression de leurs requêtes en temps réel. Il fournit des informations sur l'état d'une requête, telles que le pourcentage d'achèvement, le temps écoulé et le temps restant estimé, ainsi que le plan d'exécution utilisé par SQL Server pour traiter la requête.

Pour cela, créez un SnorqlMetricsResource.ktfichier à l'intérieur src/main/kotlin/com/hawkeye/resourceset ajoutez le code ci-dessous.

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

Créer et exécuter l'application

Nous sommes prêts à exécuter notreHawkeyeApplication

Pour ce faire, ajoutez la configuration comme indiqué ci-dessous :

Notez que nous avons ajouté server src/main/resources/config.ymldes arguments au programme. Cela indique à l'application Dropwizard de s'exécuter en tant que serveur et par rapport à l'emplacement du fichier de configuration fourni.

Si tout se passe bien, vous devriez voir quelque chose comme ça dans le terminal. Si ce n'est pas le cas et que vous êtes crié avec des erreurs, ne vous inquiétez pas, je vous couvre également pour cela. Rendez-vous dans la section FAQ et vérifiez les erreurs/résolutions auxquelles j'ai été confronté.

Rendez-vous sur Postman ou tout autre outil similaire et testez l'API. Cliquez sur Importer -> Texte brut -> Copiez collez l'appel curl ci-dessous -> Cliquez sur Continuer -> Cliquez sur Envoyer

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

Ici, nous avons interrogé pour voir toutes les requêtes actives pour la base de données db-prod. La réponse est divisée en 3 parties :

metricInput

Cela renvoie l'entrée fournie par l'utilisateur avec des valeurs par défaut dans les champs optionnels.

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

Cela vous donne la liste des requêtes en cours d'exécution à ce moment dans votre base de données ainsi que tous les paramètres pertinents qui leur sont associés. Cela peut être utile dans les scénarios suivants :

Lorsque vous essayez de déboguer l'augmentation de la latence sur votre base de données et que vous souhaitez vérifier s'il existe des requêtes de longue durée qui monopolisent votre CPU en regardant elapsedTime. Ces requêtes de longue durée peuvent être causées par divers problèmes, tels que des plans de requête inefficaces, une indexation sous-optimale ou des requêtes mal écrites. En plus de cela, nous pouvons également l'utiliser pour analyser la distribution des temps d'exécution des requêtes dans la base de données et prendre des mesures proactives pour prévenir les problèmes avant qu'ils ne surviennent.
Lorsque vous êtes dans un état où la base de données semble bloquée ou qu'un processus ne se poursuit pas, la vérification du blocage de la base de données est très logique et vous pouvez déterminer le sessionId exact bloquant cette requête à l'aide de blockedBy.
Le openTransactionCountparamètre est utilisé pour surveiller le nombre de transactions ouvertes dans une base de données à un moment donné. Si ce nombre est constamment élevé, cela peut indiquer qu'il existe des transactions qui ne sont pas validées ou annulées en temps opportun. Cela peut entraîner des problèmes tels que des conflits de ressources, un verrouillage accru et des interblocages, qui peuvent avoir un impact négatif sur les performances et la disponibilité de la base de données. En utilisant le openTransactionCountparamètre conjointement avec d'autres mesures de performances, telles que le temps d'exécution et le temps d'attente des requêtes, nous pouvons identifier correctement les requêtes qui nécessitent notre attention.

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

Cette section nous donne des détails sur les requêtes utilisées par snorql pour générer la sortie ci-dessus. Cela vient également avec une brève description et une référence rapide à la documentation officielle de Microsoft.

Les supportsHistorical& minimumRepeatIntervalfont partie d'une fonctionnalité où snorql nous aide à enregistrer et à stocker le jeu de résultats d'une sortie de requête à un intervalle donné, ce qui nous permet de revoir les données passées. Cela aidera dans les post-mortems, le triage des problèmes et la recherche d'anomalies. Cette fonctionnalité nécessite un article détaillé distinct.

"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 vous souhaitez consulter l'intégralité du code, rendez-vous ici surhttps://github.com/lakshmi-udaan/hawkeye

Prochaines étapes

Ce que nous avons fait?

Après avoir obtenu les données nécessaires, nous avons décidé de créer un puissant outil de visualisation. À cette fin, nous avons augmenté les API avec une couche d'interface utilisateur conviviale et produit le tableau de bord SQL, qui fournit à la fois une vue d'ensemble complète de toutes les bases de données et des vues détaillées et granulaires de celles individuelles. Les développeurs de notre organisation en dépendent fortement pour les tâches liées à SQL. Malheureusement, ce n'est pas actuellement open-source, mais si vous êtes intéressé, je serais heureux d'en discuter davantage. Voici un aperçu de la même chose.

Tableau de bord de diagnostic et de surveillance SQL à udaan construit à l'aide de snorql

Ce que tu peux faire?

Maintenant que vous savez utiliser snorql, ce n'est qu'une question de temps avant de libérer tout son potentiel et de commencer à augmenter les performances de votre base de données de manière exponentielle.

Vous pouvez trouver la liste de toutes les métriques disponibles ici . Vous pouvez obtenir ces métriques en modifiant simplement les paramètres transmis à l'intérieur SqlMetricManager.getMetric()comme nous l'avons fait lors de la création du point de terminaison API pour les requêtes actives ici .

Dans mon prochain article, nous approfondirons la manière dont nous pouvons utiliser certaines de ces mesures pour améliorer la productivité de votre base de données à 10x.

Merci d'avoir lu!

FAQ

Impossible de trouver l'artefact com.udaan.snorql:snorql-framework:pom:0.5.6 dans xyz
Solution : faites un fichier mvn clean install. Cela nettoiera tout ce qui a été créé à partir de la version précédente, puis créera votre projet et ajoutera les jars à votre référentiel Maven local (.m2\repository)
Si vous êtes invité avec cette erreur Solution : Vous devez charger . Vous avez oublié d'ajouterjava.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