Erste Schritte mit Schnorcheln

Mar 16 2023

Nun, die Situation in Udaan war auch nicht so anders und da beschlossen einige von uns, die Sache selbst in die Hand zu nehmen und ein Tool zu entwickeln, das dabei helfen würde, diese Probleme präventiv anzugehen. Geben Sie ein … Was ist Schnorchel? snorql ist ein in Udaan entwickeltes Open-Source-Projekt mit dem Ziel, datenbankbezogene Probleme mithilfe von SQL-Metriken zu überwachen und zu diagnostizieren.

Was können Sie von diesem Beitrag erwarten?
Kennen Sie Ihre Tools
– Dropwizard
– Kotlin
– Maven
Einrichten Ihres lokalen Computers
Einrichten Ihrer Anwendung
– Erstellen eines neuen Projekts
– Hinzufügen von Abhängigkeiten
– Erstellen und Kompilieren
– Projektstruktur
– Code
Erstellen Sie die Anwendung und führen Sie sie aus
Nächste Schritte
FAQs

Eingeben …

Was ist Schnorchel?

snorql ist ein in Udaan entwickeltes Open-Source-Projekt mit dem Ziel, datenbankbezogene Probleme mithilfe von SQL-Metriken zu überwachen und zu diagnostizieren.

Es bietet Einblick in die Leistung jeder Datenbank, sodass Sie mit dem Ratespiel aufhören und ganz einfach mit der Optimierung Ihrer Datenbanken beginnen können. Und ich kann Ihnen sagen, dass diese zusätzliche Sichtbarkeit für unsere Organisation eine entscheidende Veränderung bedeutet hat. Es hat die Verantwortung jedes Teams gestärkt.

Die Ergebnisse sprechen für sich. Danke an Schnorchel,

Wir haben eine Leistungssteigerung bei über 50 Datenbanken festgestellt.
Reduzierte Cloud-Kosten um mehr als 60 %.
Erhöhte Entwicklerproduktivität
Reduzierte Debugging-Zeit

Wenn meine Einleitung Ihre Begeisterung geweckt hat und Sie es kaum erwarten können, loszulegen, sind Sie hier genau richtig. Wenn Sie jedoch noch mehr Überzeugungsarbeit benötigen, schauen Sie sich unbedingt den fantastischen Artikel mit dem Titel „ snorql – diagnose von Datenbanken wie ein Chef“ an .

Was können Sie von diesem Beitrag erwarten?

Snorql stellt mehrere Metriken wie aktive Abfragen, blockierte Abfragen, Indexstatistiken, Datenbankwachstum usw. zur Verfügung. Die vollständige Liste finden Sie hier . Für diesen Beitrag werden wir aktive Abfragen aufgreifen. Active Queries ist ein wertvolles Tool für SQL Server-Benutzer, die die Leistung ihrer Abfragen in Echtzeit überwachen und optimieren müssen.

In diesem Beitrag zeige ich Ihnen, wie Sie die Integration snorqlin eine einfache Kotlin Dropwizard-Anwendung durchführen ( Sie können dasselbe auch in jedem anderen Java Framework replizieren ). Am Ende dieses Tutorials stellt Ihre Anwendung eine RESTful-API bereit, mit der Sie die Live-Abfragestatistiken für jede beliebige Datenbank ermitteln können.

Kennen Sie Ihre Werkzeuge

Wer bereits mit Kotlin, Dropwizard und Maven vertraut ist, kann diesen Abschnitt gerne überspringen.

Dropwizard

Dropwizard ist ein leichtes Java-Framework zum Erstellen von RESTful-Webdiensten. Dropwizard fasst stabile Bibliotheken wie Jersey, Jackson und JDBI in einem leichten Paket zusammen. Weitere Informationen finden Sie unterhttps://www.dropwizard.io/en/latest/.

Interessante Tatsache: Dropwizard wurde von Ruby on Rails inspiriert, einem beliebten Webanwendungs-Framework in der Programmiersprache Ruby. Die Entwickler von Dropwizard wollten dem Java-Ökosystem das gleiche Maß an Produktivität und Benutzerfreundlichkeit verleihen.

Kotlin

Kotlin ist eine Programmiersprache, die funktionale und objektorientierte Programmierung unterstützt und von JetBrains, einem Softwareentwicklungsunternehmen mit Sitz in Russland, entwickelt wurde. Die Syntax und die Konzepte von Kotlin ähneln denen von C#, Scala und Java. Weitere Informationen finden Sie unterhttps://kotlinlang.org/

Eine lustige Tatsache über Kotlin ist, dass sein Name tatsächlich von einer Insel in der Nähe von St. Petersburg, Russland, namens Kotlin Island, abgeleitet ist. Die Macher von Kotlin haben diesen Namen gewählt, weil viele von ihnen in oder um St. Petersburg leben und die Insel ein bekanntes Wahrzeichen der Gegend ist.

Maven

Maven ist ein Build-Automatisierungs- und Verwaltungstool für Java. Mit Maven ist es einfach, den Aufbau der Software und die Abhängigkeiten zu definieren.

Interessante Tatsache: Maven wurde 2002 von Jason van Zyl gegründet, als er am O'Hare Airport in Chicago auf einen Flug wartete.

Einrichten Ihres lokalen Computers

Sie werden viele Artikel und YouTube-Videos dazu finden, ich habe jedoch einige Kurzreferenzen beigefügt

Maven installieren und einrichten –https://www.freecodecamp.org/news/how-to-get-started-with-maven-36851d8cfd96/
Kotlin installieren –https://www.oreilly.com/library/view/kotlin-cookbook/9781492046660/ch01.html
IntelliJ installieren –https://www.jetbrains.com/help/idea/installation-guide.html

In diesem Abschnitt wird davon ausgegangen, dass Sie Maven, Kotlin und IntelliJ (oder eine andere IDE mit Unterstützung für Maven-Projekte) bereits eingerichtet haben.

Erstellen eines neuen Projekts

Klicken Sie auf Datei –> Neu –> Projekt –> Maven. Sie sehen das folgende Popup

3. Ihre IDE öffnet die Datei pom.xml mit dem Projekt mit der folgenden Struktur.

Abhängigkeiten hinzufügen

Bevor wir mit der Implementierung beginnen, müssen wir der Datei spezifische Abhängigkeiten hinzufügen, die für das Projekt erforderlich sind pom.xml. Machen wir es zusammen.

Wir beginnen mit der Definition der Versionen von Kotlin und Dropwizard im Properties-Tag.

<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

Wir benötigen diese Abhängigkeit, um Verbindungen zur Datenbank herzustellen. Ich verwende hier jdbi3. Dies funktioniert mit jeder Version von JDBC/JDBI.

Eigenschaften:

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

Wir müssen dies hinzufügen, damit die Anwendung erfolgreich eine Verbindung zur SQL Server-Datenbank herstellen kann. Wenn Sie dies weglassen, erhalten Sie die berüchtigte java.sql.SQLException: No suitable driver foundAusnahme. Hier verwende ich das snorql-extensionsModul, das uns vordefinierte Metriken entsprechend dem SQL Server liefert, daher verwenden wir diesen Treiber.

Es gibt ein weiteres Modul, snorql-frameworkdas das Grundgerüst des zugrunde liegenden Tools darstellt. Ich werde das in einem kommenden Artikel untersuchen, in dem wir erfahren, wie wir dieses Framework für verschiedene Datenbanken wie Postgres, MySQL usw. nutzen können.

Eigenschaften:

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

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

Nun, das kann ich nicht weglassen!

Eigenschaften:

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

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

Erstellen und kompilieren

Der nächste Schritt besteht darin, die Quellverzeichnisse in <sourceDirectory>und in anzugeben <testSourceDirectory>, um den Quellcode zu kompilieren. Wir werden auch das Kotlin-Plugin konfigurieren, das zum Kompilieren unseres Quellcodes erforderlich ist.

Fügen Sie den Code pom.xmlwie im Abschnitt „Abhängigkeiten“ gezeigt hinzu

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

Sobald Sie dies tun, wird Kotlin rot hervorgehoben. Dies liegt daran, dass der Pfad derzeit nicht existiert, was uns zum nächsten Abschnitt → Projektstruktur bringt

Projektstruktur

Das ist meine Projektstruktur. Sie können zunächst dasselbe verwenden und es später entsprechend Ihren Anforderungen anpassen.

Code

Schritt 1: Wir beginnen mit der Erstellung einer config.ymlDatei darin src/main/resources. In dieser Konfigurationsdatei können wir Parameter definieren, die in eine Instanz unserer Konfigurationsklasse deserialisiert werden. Wir müssen mindestens einen Parameter hinzufügen, sonst gibt das Dropwizard-Framework beim Kompilieren einen Fehler aus. Machen wir weiter und fügen Folgendes hinzu:

environment: local

package com.hawkeye.configuration

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


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

Schritt 4: Als nächstes erstellen wir BootstrapSnorqlApplicationeine .kt-Datei im Pfad src/main/kotlin/com/hawkeyeund fügen den folgenden Code hinzu:

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

Schritt 5: Jetzt müssen wir die ConnectionSchnittstelle implementieren, die snorql-frameworkverfügbar macht. Nennen wir es SqlServerConnectionund es enthält die Methoden, die für snorqldie Interaktion mit der Datenbank des Benutzers erforderlich sind. Für diesen Beitrag run()würde die Implementierung der Methode allein ausreichen. Die anderen werden wir in einem separaten ausführlichen Blogbeitrag näher beleuchten.

Erstellen Sie eine SqlServerConnection.ktDatei im Pfad src/main/kotlin/com/hawkeye/coreund fügen Sie den folgenden Code hinzu.

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 stellt viele nützliche SQL-Metriken bereit, die in Ihre Anwendung integriert und verwendet werden können. Für diesen Beitrag wählen wir die Metrik aus, die für jeden, der jemals eine Datenbank verwendet hat, am relevantesten ist – Active Queries.

Aktive Abfragen, auch Live-Abfragestatistiken genannt, sind eine Funktion in SQL Server, mit der Benutzer den Fortschritt ihrer Abfragen in Echtzeit überwachen können. Es liefert Informationen zum Status einer Abfrage, wie z. B. den Prozentsatz der Fertigstellung, die verstrichene Zeit und die geschätzte verbleibende Zeit, sowie den Ausführungsplan, den SQL Server zum Verarbeiten der Abfrage verwendet.

Erstellen Sie dazu eine SnorqlMetricsResource.ktDatei src/main/kotlin/com/hawkeye/resourcesund fügen Sie den folgenden Code hinzu.

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

Erstellen Sie die Anwendung und führen Sie sie aus

Wir sind bereit, unsere zu startenHawkeyeApplication

Fügen Sie dazu die Konfiguration wie unten gezeigt hinzu:

Beachten Sie, dass wir server src/main/resources/config.ymlden Programmargumenten hinzugefügt haben. Dadurch wird die Dropwizard-App angewiesen, als Server und am Speicherort der bereitgestellten Konfigurationsdatei ausgeführt zu werden.

Wenn alles gut geht, sollten Sie im Terminal so etwas sehen. Wenn nicht, und Sie mit einigen Fehlern angeschrien werden, machen Sie sich keine Sorgen, ich bin auch dafür auf der sicheren Seite. Gehen Sie zum FAQ-Bereich und sehen Sie sich die Fehler/Lösungen an, mit denen ich konfrontiert war.

Gehen Sie zu Postman oder einem anderen ähnlichen Tool und testen Sie die API. Klicken Sie auf Importieren -> Rohtext -> Kopieren und fügen Sie den unten angegebenen Curl-Aufruf ein -> Klicken Sie auf Weiter -> Klicken Sie auf Senden

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

Hier haben wir eine Abfrage durchgeführt, um alle aktiven Abfragen für die Datenbank anzuzeigen db-prod. Die Antwort gliedert sich in 3 Teile:

metrische Eingabe

Dies gibt die vom Benutzer bereitgestellten Eingaben mit Standardwerten in optionalen Feldern zurück.

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

Dadurch erhalten Sie eine Liste der derzeit in Ihrer Datenbank ausgeführten Abfragen sowie alle damit verbundenen relevanten Parameter. Dies könnte in den folgenden Szenarien nützlich sein:

Wenn Sie versuchen, die erhöhte Latenz in Ihrer Datenbank zu debuggen und überprüfen möchten, ob es lang laufende Abfragen gibt, die Ihre CPU belasten, indem Sie sich Folgendes ansehen elapsedTime: Diese lang andauernden Abfragen können durch eine Vielzahl von Problemen verursacht werden, beispielsweise durch ineffiziente Abfragepläne, suboptimale Indizierung oder schlecht geschriebene Abfragen. Darüber hinaus können wir damit auch die Verteilung der Abfrageausführungszeiten in der Datenbank analysieren und proaktive Maßnahmen ergreifen, um Probleme zu verhindern, bevor sie auftreten.
Wenn Sie sich in einem Zustand befinden, in dem die Datenbank blockiert zu sein scheint oder ein Prozess nicht ausgeführt wird, ist die Prüfung auf Datenbankblockierung sehr sinnvoll und Sie können mithilfe von die genaue Sitzungs-ID ermitteln, die diese Abfrage blockiert blockedBy.
Der openTransactionCountParameter wird verwendet, um die Anzahl der offenen Transaktionen in einer Datenbank zu einem bestimmten Zeitpunkt zu überwachen. Wenn dieser Wert konstant hoch ist, kann dies darauf hindeuten, dass es Transaktionen gibt, die nicht rechtzeitig festgeschrieben oder zurückgesetzt werden. Dies kann zu Problemen wie Ressourcenkonflikten, erhöhten Sperren und Deadlocks führen, die sich negativ auf die Leistung und Verfügbarkeit der Datenbank auswirken können. Durch die Verwendung des openTransactionCountParameters in Verbindung mit anderen Leistungsmetriken, wie etwa der Abfrageausführungszeit und der Abfragewartezeit, können wir die Abfragen, die unsere Aufmerksamkeit erfordern, korrekt identifizieren.

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

In diesem Abschnitt erfahren Sie mehr über die Abfragen, die Snorql verwendet, um die obige Ausgabe zu generieren. Dazu gehört auch eine kurze Beschreibung und ein kurzer Verweis auf die offizielle Microsoft-Dokumentation.

Die supportsHistorical& minimumRepeatIntervalsind Teil einer Funktion, mit der uns snorql dabei hilft, die Ergebnismenge einer Abfrageausgabe in einem bestimmten Intervall aufzuzeichnen und zu speichern, sodass wir frühere Daten erneut aufrufen können. Dies hilft bei Obduktionen, bei der Problemselektion und beim Auffinden von Anomalien. Für diese Funktion ist ein separater ausführlicher Beitrag erforderlich.

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

Wenn Sie sich den gesamten Code ansehen möchten, besuchen Sie ihn hier unterhttps://github.com/lakshmi-udaan/hawkeye

Nächste Schritte

Was wir gemacht haben?

Nachdem wir die erforderlichen Daten erhalten hatten, machten wir uns daran, ein leistungsstarkes Visualisierungstool zu entwickeln. Zu diesem Zweck haben wir die APIs um eine benutzerfreundliche UI-Ebene erweitert und das SQL Dashboard erstellt, das sowohl eine umfassende Vogelperspektive aller Datenbanken als auch detaillierte, granulare Ansichten einzelner Datenbanken bietet. Die Entwickler unserer Organisation verlassen sich bei SQL-bezogenen Aufgaben stark darauf. Bedauerlicherweise ist es derzeit nicht Open Source, aber wenn Sie interessiert sind, freue ich mich über weitere Diskussionen. Hier ist ein kleiner Vorgeschmack davon.

SQL-Diagnose- und Überwachungs-Dashboard bei udaan, erstellt mit Snorql

Was du tun kannst?

Nachdem Sie nun wissen, wie man Snorql verwendet, ist es nur eine Frage der Zeit, bis Sie das volle Potenzial ausschöpfen und die Leistung Ihrer Datenbank exponentiell steigern.

Die Liste aller verfügbaren Metriken finden Sie hier . Sie können diese Metriken erhalten, indem Sie einfach die darin übergebenen Parameter ändern, SqlMetricManager.getMetric()wie wir es hier beim Erstellen des API-Endpunkts für aktive Abfragen getan haben .

In meinem nächsten Beitrag werden wir uns eingehend damit befassen, wie wir einige dieser Metriken nutzen können, um die Produktivität Ihrer Datenbank um das Zehnfache zu steigern.

Danke fürs Lesen!

FAQs

Das Artefakt com.udaan.snorql:snorql-framework:pom:0.5.6 konnte in xyz nicht gefunden werden.
Lösung: Führen Sie eine mvn clean install. Dadurch wird alles bereinigt, was im vorherigen Build erstellt wurde. Anschließend wird Ihr Projekt erstellt und die JAR-Dateien zu Ihrem lokalen Maven-Repository (.m2\repository) hinzugefügt.
Wenn diese Fehlermeldung angezeigt wird : Lösung: Sie müssen . laden . Sie haben das Hinzufügen verpasstjava.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