Reporting performance issues
To figure out what is causing a performance issue, you have to collect and submit certain troubleshooting materials to the JetBrains support team. The type of the troubleshooting material depends on the issue that you experience.
You can review the information that is included in the generated HPROF and SNAPSHOT files by using any Java profiler (for example, YourKit). To review HPROF files, you can also use the profiler of Intellij IDEA Ultimate ( ).
The following situations might take place:
The IDE does not respond: the application hangs and does not respond to any action for a long time.
High CPU usage: the application is working but your performance monitoring utility shows that the application CPU usage is high.
High memory consumption or a memory leak: the application is working, but your performance monitoring utility shows that the application memory consumption is high.
Slow indexing: the indexing process became slower or cannot be finished.
Slow startup: the startup process takes a lot of time.
Slow or incorrect introspection: a retrieval of database objects is
The IDE does not respond
When DataGrip does not respond, consider creating a thread dump file. A dump file must be created at the moment when the IDE does not respond and include the thread stack. Recording several thread dumps with 1-2 seconds interval might be very useful for the problem analysis.
After you have created a dump thread file, archive it, and upload it to share with the JetBrains support team. Read upload instructions in the Upload snapshots section.
You can create thread dumps by using the following options:
The jstack command-line utility prints Java stack traces of Java threads. The utility is provided with the JDK installation and can be found in the JAVA_HOME\bin directory.
Ensure that the utility has the same JDK version as DataGrip. For example, the 64-bit JDK distribution of the utility will not work for the IDE that runs under the 32-bit JDK distribution. To check the JDK version, press Ctrl+Shift+A, type
About, and press Enter.
Create thread dumps by using jstack
Open the command prompt.
List Java processes that run on your system with their command-line options. Type the following command and press Enter.jps -mv
Run jstack with the IDE process identifier (PID). Type the following command and press Enter.jstack -l <PID> > dump.txt
This command prints the thread dump into a file.
Automatic thread dumps
DataGrip runs a thread that detects when UI does not respond for a certain time and writes automatic thread dumps into the log directory. To find the log directory, click
threadDumps-freeze-20201215-083634-DB-211.3076. Zip these folders and attach them to your ticket.
Thread dump from the console
Depending on your operating system, you can create a thread dump without the jstack utility.
Navigate to the datagrip file in IDE_HOME/DataGrip.app/Contents/MacOS/.
Depending on how you installed your IDE, IDE_HOME might be /Applications/ (standalone installation) or ~/Library/Application Support/JetBrains/Toolbox/apps/datagrip/ch-2/203.5981.102/ (Toolbox installation).
Right-click the datagrip file and select .
Press ^\. The terminal will print a thread dump. To complete the process, press ^C.
Open the command prompt.
By using the
cdcommand, navigate to the datagrip.bat file in the bin directory inside your IDE installation directory.
Depending on how you installed your IDE, the installation directory might be C:\Program Files\JetBrains\DataGrip 2020.3\ (standalone installation) or C:\Users\User\AppData\Local\JetBrains\Toolbox\apps\datagrip\ch-1\211.3208\ (Toolbox installation).
Run the datagrip.bat file.datagrip.bat > output.txt
Press Ctrl+Break. The terminal will print a thread dump. To complete the process, press Ctrl+C.
Run the datagrip.sh file in the bin directory inside your IDE installation directory.
Depending on how you installed your IDE, the installation directory might be any directory that you have chosen (standalone installation) or ~/.local/share/JetBrains/Toolbox/apps/DataGrip/ch-0/211.3208 (Toolbox installation).
By using a process manager (for example,
jps), get the process ID (PID).
Run the following command or send the SIGQUIT signal to the process. A thread dump will be printed in the terminal window.
High CPU usage
If you can continue working with the IDE, but the IDE hangs, repeatedly stops responding, displays you warnings about memory consumption, try to close large files (for example, SQL files with thousands of rows), and restart the IDE.
Otherwise, capture the CPU snapshot and IDE logs and send them to the JetBrains support team.
Start CPU usage profiling
DataGrip might ask you to restart IDE to add necessary VM options. If you see this notification, restart the IDE and start the CPU usage profiling again.
Perform the actions that cause performance issues. Try to reproduce the performance problem several times while the snapshot is being recorded.
DataGrip saves the snapshot file in the user home directory. If you do not see the notification, enable balloon notifications for Profiling in settings. Open settings by pressing Ctrl+Alt+S and navigate to . In the list of components, find profiler notifications and ensure that the Popup type is Balloon.
High memory consumption or a memory leak
The Java Virtual Machine (JVM) running DataGrip allocates some predefined amount of memory. The default value depends on the platform. If you are experiencing slowdowns, you may want to increase the memory heap.
From the main menu, select.
Set the necessary amount of memory that you want to allocate and click Save and Restart.
This action changes the value of the
-Xmx option used by the JVM and restarts DataGrip with the new setting.
DataGrip also warns you if the amount of free heap memory after a garbage collection is less than 5% of the maximum heap size:
Click Configure to increase the amount of memory allocated by the JVM. If you are not sure what would be a good value, use the one suggested by DataGrip.
Click Save and Restart and wait for DataGrip to restart with the new memory heap setting.
If these settings do not fix the problem, capture a memory snapshot, and send it to the JetBrains support team.
Capture a memory snapshot
Alternatively, press Ctrl+Shift+A, type
capture memory, and select Capture Memory Snapshot.
Wait until the HPROF snapshot is built. You can navigate to it from the notification balloon.
You can capture memory snapshots automatically when the IDE runs out of memory.
Capture memory snapshots automatically
In the VMOPTIONS file, add the following lines:-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=$USER_HOME/java_error_in_datagrip.hprof
According to the
HeapDumpPathparameter, the HPROF file will be created in the user directory. Alternatively, specify any other directory that has read-write access.
Profile the indexing process
Click Invalidate and Restart.
Wait until DataGrip loads and indexes project files.
Click the Open Snapshot In link to locate the snapshot.
Create a snapshot and share it with the JetBrains support team.
In the The Next Startup Will Be Profiled window, click Restart.
In the Startup profiling in progress window, click Show Profile Location.
When you close the IDE, the SNAPSHOT file will appear in the Snapshots directory.
Slow or incorrect introspection
Introspection is the process during which the IDE retrieves information about a database. This information is used to show the objects in the database explorer, display their DDL, suggest them during completion, and in other features for code assistance.
Sometimes introspection runs into problems. For example, it might take much longer time to introspect a database, or some objects that exist in the database do not show up in the Database Explorer. In these cases, try to use the following menu items to collect troubleshooting data and pass it on to our support team.
As you collected all the needed troubleshooting materials, consider passing them on to our support team.
Collect information by using Diagnostic tools
Right-click a data source and navigate to. Select between the following options:
Dump Model: generates a DataGrip-specific representation of the database structure (a database model). You can include automatically generated content by clicking the Include auto-generated content icon.
Diagnostic Refresh: reloads the metadata from the database and generates a LOG file. This information might be helpful for the support team when you think that your introspection is slow.
Prepare Introspector Diagnostics: generates three files that include information about the data source (dataSource.txt), a module that was used to load the metadata from the database (introspector.txt), and a part of the database model (model.xml).
This information might be helpful when introspection works incorrectly. For example, when you see something outdated or do not see new objects.
The following screenshot shows the example output of these three files.
If your snapshot is smaller than 10 MB, you can attach it directly to support tickets or YouTrack issues.
For files larger than 10 MB, use the JetBrains Uploads Service. After the upload is successful, share the Upload ID in the related support case or the Youtrack issue. For more information about getting help, see Support and assistance.
Consider archiving large or multiple files before uploading. If your upload speed is slow, split large archives into smaller parts.
Reporting your problem
To report an issue, you can use any option that is described in the Where to report an issue section. But we recommend using the JetBrains Support Center.
Submit a request in the JetBrains Support Center
Fill in the Submit a request form.
If it is possible, attach some troubleshooting materials.