Difference between revisions of "Guidelines and HOWTOs/Bug triaging"

m (Ochurlaud moved page Bugsquad/Guide To BugTriaging to Guidelines and HOWTOs/Bug triaging: It goes there)
 
(34 intermediate revisions by 8 users not shown)
Line 1: Line 1:
Initial version by [[User:DarioAndres|Dario Andres]] (2010-03/2010-04).
+
[[File:Mascot konqi-support-bughunt.png|thumbnail|right|Help [[Konqi]] catch some bugs!]]
 +
The '''KDE Bugsquad''' keeps track of incoming bugs in KDE software, and goes through old bugs. We verify that a bug exists, whether it is reproducible, and that the reporter has given enough information. '''Our goal is to save developers from doing this, which helps them fix bugs more quickly and do more work on KDE software.'''
  
Initial corrections by Lydia Pintscher (Nightrose)
+
Getting involved in the Bugsquad is a good place to start. An existing member will help you out and mentor you. One of the great things about the Bugsquad and bug triaging is that '''you do not need any programming knowledge!''' That said, experience has shown that members of this team learn a lot about KDE and Qt programming during the course of dealing with bug reports, and many move on to developing the software itself. If you are just starting to learn programming, bug triaging is a great way to gain familiarity with the components and give practical support to the KDE community.
  
===Disclaimer===
+
For live chat, we have the '''#kde-bugs''' [[Internet_Relay_Chat|IRC channel]] on [https://freenode.net/ Freenode]. Please feel free to stop by! You can also connect via [https://matrix.org/ Matrix] if you prefer.
  
This "ultimate" guide is based on my own experience (approximately 2 years) on the KDE bug tracker.
+
To join the Bugsquad, [https://phabricator.kde.org/project/update/290/join/ become a member] of our [https://phabricator.kde.org/project/profile/290/ project on Phabricator]. We organize Bug Days, where we focus on a specific product, with the goal of reviewing all open bugs by the end of the day. These meetings occur primarily on #kde-bugs.
  
I hope it works for you too :)
+
We have a [https://phabricator.kde.org/calendar/query/Tp0Fc0J7sB6v/ Bugsquad calendar] you can view or export as ICS to your calendar of choice. The calendar lists all of the upcoming Bug Days and what product we will be focusing on. These days are great times to get involved and ask questions!
  
=General Considerations=
+
= General considerations =
 +
* '''Be polite.''' Bug triagers are the face of KDE. Be nice to bug reporters, even if they aren't nice to you! You have an opportunity to showcase the best of the KDE community, and turn skeptics into fans. Being nice is more impactful than being right.
 +
* '''Explain your decisions.''' It can be very frustrating for a bug reporter if his/her report is suddenly closed without any reason. Write why you think that your action is the correct one, and don't establish your opinion as the all-ruling fact.
 +
* '''Don't be afraid to make mistakes.''' Everybody does make mistakes, especially when starting out with bug triaging.
 +
* KDE uses the Bugzilla bug tracker system. If you are not familiar with it, you may find this [[Bugsquad/Quick Introduction to Bugzilla|quick Introduction to Bugzilla]] useful.
 +
* The [https://addons.mozilla.org/en-US/firefox/addon/bugzillajs/ BugzillaJS add-on for Firefox] is highly recommended, as it greatly improves the user experience.
  
* '''Be polite''': when you need to request information or feedback be clear and polite, and you will get more information in less time. 
Often Bugzilla is a place which involves discussions (about implementations, or even about contributors). Try to be concise and polite, respecting the other's position while describing your own.
+
= Decide what to work on =
 
+
=== All bugs filed recently ===
* Don't try to do too many things at the same time; otherwise you will end up with a headache.
 
 
 
If you are not familiar with the Bugzilla (KDE bug tracker system) interface, you may find this guide useful: [http://techbase.kde.org/Contribute/Bugsquad/Quick_Introduction_to_Bugzilla Quick Introduction to Bugzilla]
 
 
 
You may want to properly setup your bugzilla account as mentioned at [http://techbase.kde.org/Contribute/Bugsquad/Quick_Introduction_to_Bugzilla#Configure_your_account_.28Important.29 Configure your account]
 
 
 
=About getting permissions to work in the bug tracker=
 
 
 
Manpower is always needed in a bug tracker, but as any action taken on it may be potentially destructive to other people's work; or it may end up messing things up (and consuming the developers' or other triager's time) the tracker requires special permissions to perform changes in bug reports.
 
 
 
If you want to work in the bug tracker you need to prove that you know what you are doing.
 
 
 
Initially you will ask for support on '''#kde-bugs''' (on IRC) and add comments in the bug report (so other people will see and check them, perform the needed actions, and evaluate your work)
 
 
 
{{Note|Adding comments in a bug report is allowed for every user}}
 
 
 
=Getting Started: Find what to work on (Different Approaches)=
 
 
 
You could use different techniques or approaches to triage the reports according to your current mood or the amount of work you want to do for example.
 
 
 
{{Tip|The two following techniques are complementary.}}
 
 
 
==Check all the bug reports of the day==
 
 
 
In this technique you check all the bug reports (of all the products) which were filed today (or some days ago).
 
 
 
You can focus on crash, normal or wish reports individually (recommended) or all of them together.
 
 
 
'''Good:'''
 
* You get a complete view of all the reports
 
* You can easily recognize possible duplicates if the report titles are appropriate
 
* You can choose any report
 
* You can quickly clean the bugs that were filed recently (keeping them from rotting)
 
* You can get quick feedback from the reporter
 
 
 
'''Not so Good:'''
 
* You don't focus on one product
 
* You may not pay too much attention to every report, as you are triaging different kinds of reports
 
* You need a lot of attention to handle the different reports (at the ~same~ time)
 
 
 
This technique could be used ''every week'' (or every day)
 
 
 
===Bugzilla Links===
 
 
* All the bugs ('''any type''') reported [https://bugs.kde.org/buglist.cgi?bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_status=UNCONFIRMED&bugidtype=include&chfield=%5BBug+creation%5D&chfieldfrom=1d&chfieldto=Now&bug_file_loc=&cmdtype=doit today] or the [https://bugs.kde.org/buglist.cgi?bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_status=UNCONFIRMED&bugidtype=include&chfield=%5BBug+creation%5D&chfieldfrom=7d&chfieldto=Now&bug_file_loc=&cmdtype=doit last week]
 
* All the bugs ('''any type''') reported [https://bugs.kde.org/buglist.cgi?bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_status=UNCONFIRMED&bugidtype=include&chfield=%5BBug+creation%5D&chfieldfrom=1d&chfieldto=Now&bug_file_loc=&cmdtype=doit today] or the [https://bugs.kde.org/buglist.cgi?bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_status=UNCONFIRMED&bugidtype=include&chfield=%5BBug+creation%5D&chfieldfrom=7d&chfieldto=Now&bug_file_loc=&cmdtype=doit last week]
 
* All the '''crashes''' reported [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_severity=crash&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=1d&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= today] or the [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_severity=crash&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=7d&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= last week]
 
* All the '''crashes''' reported [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_severity=crash&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=1d&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= today] or the [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_severity=crash&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=7d&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= last week]
Line 61: Line 24:
 
* All the '''feature requests''' reported [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_severity=wishlist&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=1d&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= today] or the [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_severity=wishlist&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=7d&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= last week]
 
* All the '''feature requests''' reported [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_severity=wishlist&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=1d&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= today] or the [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_severity=wishlist&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=7d&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= last week]
  
==Check bug reports of a single product over a period of time==
+
=== All bug reports of a single product ===
 
+
You'll want to use the Advanced search for this: https://bugs.kde.org/query.cgi
Choose a product (application or library). Then choose a period of time like 1 month or 1 or 2 years (or "from the beginning of the current year", or even from the very beggining (like 2000)). You can also choose which kind of reports you want to handle.
 
 
 
This technique is useful to audit old bugs or perform a deep clean (in case that the bugs weren't triaged on a daily basis previously).
 
 
 
'''Good:'''
 
* You focus only on one product / topic, so you don't need to pay too much attention (pay attention anyways!)
 
 
 
'''Not so Good:'''
 
* The reports of the other application may rot if they aren't checked
 
* You may not get feedback if the report is too old or the reporter is not accessible anymore
 
 
 
You can also filter out results (and be even more focused) if you select a custom component inside the product (a subsection of the application).
 
 
 
This technique could be used ''two times a month''.
 
  
===Bugzilla Links===
+
You can see which products are most in need of bug triaging here, with links to their bug lists: https://bugs.kde.org/weekly-bug-summary.cgi?tops=50&days=7
  
* Template search for all the reports of any status, since 2008: [https://bugs.kde.org/query.cgi?bug_file_loc=&bug_file_loc_type=allwordssubstr&bug_id=&bugidtype=include&chfield=%5BBug%20creation%5D&chfieldfrom=2008-01-01&chfieldto=Now&chfieldvalue=&email1=&email2=&emailassigned_to1=1&emailassigned_to2=1&emailcc2=1&emailreporter2=1&emailtype1=substring&emailtype2=substring&field-1-0-0=product&field-1-1-0=bug_severity&field0-0-0=noop&keywords=&keywords_type=allwords&long_desc=&long_desc_type=allwordssubstr&product=plasma&query_format=advanced&remaction=&short_desc=&short_desc_type=allwordssubstr&type-1-0-0=anyexact&type-1-1-0=anyexact&type0-0-0=noop&value-1-0-0=plasma&value-1-1-0=crash&value0-0-0=&votes= any kind of report], [https://bugs.kde.org/query.cgi?bug_file_loc=&bug_file_loc_type=allwordssubstr&bug_id=&bug_severity=crash&bugidtype=include&chfield=%5BBug%20creation%5D&chfieldfrom=2008-01-01&chfieldto=Now&chfieldvalue=&email1=&email2=&emailassigned_to1=1&emailassigned_to2=1&emailcc2=1&emailreporter2=1&emailtype1=substring&emailtype2=substring&field-1-0-0=product&field-1-1-0=bug_severity&field0-0-0=noop&keywords=&keywords_type=allwords&long_desc=&long_desc_type=allwordssubstr&product=plasma&query_format=advanced&remaction=&short_desc=&short_desc_type=allwordssubstr&type-1-0-0=anyexact&type-1-1-0=anyexact&type0-0-0=noop&value-1-0-0=plasma&value-1-1-0=crash&value0-0-0=&votes= crashes], [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&product=plasma&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_severity=critical&bug_severity=grave&bug_severity=major&bug_severity=normal&bug_severity=minor&emailassigned_to1=1&emailtype1=substring&email1=&emailassigned_to2=1&emailreporter2=1&emailcc2=1&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=2008-01-01&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= normal bugs], [https://bugs.kde.org/query.cgi?bug_file_loc=&bug_file_loc_type=allwordssubstr&bug_id=&bug_severity=wishlist&bugidtype=include&chfield=%5BBug%20creation%5D&chfieldfrom=2008-01-01&chfieldto=Now&chfieldvalue=&email1=&email2=&emailassigned_to1=1&emailassigned_to2=1&emailcc2=1&emailreporter2=1&emailtype1=substring&emailtype2=substring&field-1-0-0=product&field-1-1-0=bug_severity&field0-0-0=noop&keywords=&keywords_type=allwords&long_desc=&long_desc_type=allwordssubstr&product=plasma&query_format=advanced&remaction=&short_desc=&short_desc_type=allwordssubstr&type-1-0-0=anyexact&type-1-1-0=anyexact&type0-0-0=noop&value-1-0-0=plasma&value-1-1-0=crash&value0-0-0=&votes= feature requests]
+
Here are some common and popular KDE products in need of bug triaging:
* Template search for all the open reports, since 2008: [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&product=plasma&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&emailassigned_to1=1&emailtype1=substring&email1=&emailassigned_to2=1&emailreporter2=1&emailcc2=1&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=2008-01-01&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= any kind of report], [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&product=plasma&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_severity=crash&emailassigned_to1=1&emailtype1=substring&email1=&emailassigned_to2=1&emailreporter2=1&emailcc2=1&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=2008-01-01&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= crashes], [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&product=plasma&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_severity=critical&bug_severity=grave&bug_severity=major&bug_severity=normal&bug_severity=minor&emailassigned_to1=1&emailtype1=substring&email1=&emailassigned_to2=1&emailreporter2=1&emailcc2=1&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=2008-01-01&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= normal bugs], [https://bugs.kde.org/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&product=plasma&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bug_severity=wishlist&emailassigned_to1=1&emailtype1=substring&email1=&emailassigned_to2=1&emailreporter2=1&emailcc2=1&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=2008-01-01&chfieldto=Now&chfield=%5BBug+creation%5D&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0= feature requests]
+
* Plasma [https://bugs.kde.org/buglist.cgi?bug_severity=critical&bug_severity=grave&bug_severity=major&bug_severity=crash&bug_severity=normal&bug_severity=minor&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506503&product=plasmashell&query_format=advanced bugs] / [https://bugs.kde.org/buglist.cgi?bug_severity=wishlist&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506504&product=plasmashell&query_format=advanced feature requests]
 +
* System Settings [https://bugs.kde.org/buglist.cgi?bug_severity=critical&bug_severity=grave&bug_severity=major&bug_severity=crash&bug_severity=normal&bug_severity=minor&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506503&product=systemsettings&query_format=advanced bugs] / [https://bugs.kde.org/buglist.cgi?bug_severity=wishlist&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506504&product=systemsettings&query_format=advanced feature requests]
 +
* Dolphin [https://bugs.kde.org/buglist.cgi?bug_severity=critical&bug_severity=grave&bug_severity=major&bug_severity=crash&bug_severity=normal&bug_severity=minor&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506503&product=dolphin&query_format=advanced bugs] / [https://bugs.kde.org/buglist.cgi?bug_severity=wishlist&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506504&product=dolphin&query_format=advanced feature requests]
 +
* Okular [https://bugs.kde.org/buglist.cgi?bug_severity=critical&bug_severity=grave&bug_severity=major&bug_severity=crash&bug_severity=normal&bug_severity=minor&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506503&product=okular&query_format=advanced bugs] / [https://bugs.kde.org/buglist.cgi?bug_severity=wishlist&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506504&product=okular&query_format=advanced feature requests]
 +
* Gwenview [https://bugs.kde.org/buglist.cgi?bug_severity=critical&bug_severity=grave&bug_severity=major&bug_severity=crash&bug_severity=normal&bug_severity=minor&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506503&product=gwenview&query_format=advanced bugs] / [https://bugs.kde.org/buglist.cgi?bug_severity=wishlist&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506504&product=gwenview&query_format=advanced feature requests]
 +
* Konsole [https://bugs.kde.org/buglist.cgi?bug_severity=critical&bug_severity=grave&bug_severity=major&bug_severity=crash&bug_severity=normal&bug_severity=minor&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506503&product=konsole&query_format=advanced bugs] / [https://bugs.kde.org/buglist.cgi?bug_severity=wishlist&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506504&product=konsole&query_format=advanced feature requests]
 +
* Kate & KTextEditor framework [https://bugs.kde.org/buglist.cgi?bug_severity=critical&bug_severity=grave&bug_severity=major&bug_severity=crash&bug_severity=normal&bug_severity=minor&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506507&product=frameworks-ktexteditor&product=kate&query_format=advanced bugs] / [https://bugs.kde.org/buglist.cgi?bug_severity=wishlist&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506506&product=frameworks-ktexteditor&product=kate&query_format=advanced feature requests]
 +
* KIO framework [https://bugs.kde.org/buglist.cgi?bug_severity=critical&bug_severity=grave&bug_severity=major&bug_severity=crash&bug_severity=normal&bug_severity=minor&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506508&product=frameworks-kio&product=kio&product=kio-extras&query_format=advanced bugs] / [https://bugs.kde.org/buglist.cgi?bug_severity=wishlist&bug_status=UNCONFIRMED&bug_status=CONFIRMED&bug_status=ASSIGNED&bug_status=REOPENED&list_id=1506510&product=frameworks-kio&product=kio&product=kio-extras&query_format=advanced feature requests]
  
=Workflow of the bug triaging activity=
+
= Bug editing permissions =
 +
All regular Bugzilla users can perform standard editing functions. You can change a number of fields, including the product, component, version, platform, status, and more. You are restricted from only a few abilities, such as bulk editing, changing the Priority and Severity fields (Importance), or re-opening CLOSED bugs. After getting comfortable with the KDE Bugzilla process, you can request "contributor" privileges from Sysadmin, which will allow you to perform those actions.
  
Now that you have a list of bug reports, pick one and start working.
+
= What to do with bug reports =
 +
Now that you have a list of bug reports, pick one and start working! Here is the optimal bug triaging workflow:
  
 
[[File:DarioAndres_GuideToBugTriaging_Workflow.png]]
 
[[File:DarioAndres_GuideToBugTriaging_Workflow.png]]
  
=Handling reports: What to do with a bug report=
+
{{Note|If at any point you aren't sure how to proceed, move onto the next bug or ask a KDE developer or another more experienced contributor.}}
 
 
There are several things that must be checked and "fixed" to make an initial bug report an interesting and useful piece of information for the developers to check.
 
 
 
{{Note|if at any point you don't really know how to continue, because you don't understand the issue properly, always ask to the developers or related contributors}}
 
 
 
As KDE has too many users, we get a lot of reports about bugs which are already reported (the so named "duplicates"). Before putting any effort in the current report we should check for the main report.
 
 
 
==Identifying duplicates==
 
 
 
There are a lot of ways of identifying duplicate reports depending of the kind of bug.
 
 
 
===General===
 
 
 
* Search for duplicates should be done initially against the same product of the bug report you are triaging: 
If you don't find any related issue, you may need to search in a different product.
 
 
{{Tip|You can search on different products at the same time}}
 
 
 
{{Note|Due to the heavy usage of libraries in the KDE software, a bug reported for an application may be being tracked at a library product (example, a bug in Plasma Desktop may be a bug in kdelibs, and therefore being tracked in the "kdelibs" product)}}
 
 
 
[http://techbase.kde.org/Contribute/Bugsquad/Guide_To_BugTriaging#List_of_related_KDE_technologies List of related KDE technologies]
 
 
 
* You may want to filter out the results by date: you can select a date range since some years (or months ago) to "Now" (today)
 
 
 
===For "normal" (non-crash) reports===
 
 
 
# Pick some "keywords" from the current report. This keywords need to explain the inner concept of the bug that was reported (they must represent it).
 
# Perform a full search over the same product (read general note), initially on the "general" component.
 Initially, put the keywords in the title, and perform the search (this will only look for the keywords in the title)
 
# If your search has results on it, check them all, reading the whole description and trying to identify the situation.
 
# If you don't get any results, you need to go back and:

 
#* Change your keywords (tip: select thesaurus, or similar/related concepts); or
 
#* Use the keywords in the "Comments" field (so the search will look up in the bug description and comments too)
 
 
 
{{Note|When using more than one word in the "Comments" field you need to select the option "contains all of the words/strings"}}
 
 
 
{{Note|It is sometimes difficult to choose the proper ones, as the way of describing a scene varies from person to person (but we have time)}}
 
 
 
===For "crash" reports===
 
 
 
# Perform the same operation as with normal bug reports
 
# Check for reports with duplicate backtraces: 
 (Read the [http://techbase.kde.org/Contribute/Bugsquad/Guide_To_BugTriaging#C.2B.2B_Backtraces_.28identifying_crashes_duplicates.29 Backtraces section] below)
 
 
 
Perform a full search over the same product (read general note), initially on the "general" component, putting the "ClassName::FunctionName" pairs that identify the crash in the Comments field of the form (if you put more than one pair, you need to select the option "contains all of the words/strings")
 
 
 
===Processing search results===
 
 
 
* If you don't find any similar report then we should assume the new bug reports is "unique" (and valid). See next section

 
 
 
* If you find a similar bug report we have too choices:
 
** If you are completely sure it is the same issue, you have to mark the report as duplicate. 

The bug report you initially picked (name it "copy") is going to be marked as duplicate of the original report (name it "main"). If "copy" has additional information that "main" doesn't have, you may want to add it. (Note: some details may look unimportant to you, but they may be important for developers who know about the application workflow and code. Also, adding a big amount of minimal/incomplete information you may end up generating a big and complete testcase)

 
** If you aren't completely sure: you need someone else to double check your work. You may want to add a comment in the current report. Then, you should ask in #kde-bugs IRC channel for someone to look at your comment.
 
Comment template:
 
This bug looks related to bug XXXXXX
 
(XXXXXX being the bug ID of "master")
 
 
 
{{Note|You may found related reports that are already marked as duplicate of a third report. Always try to use this third report as the "main" one (resolve the duplicates chain). However, in some cases, the "main" reports refers to a root issue, and some of its duplicates may refer to sub-issues. In those cases try to check which one refers to the issue you are looking at.}}
 
 
 
==Identifying duplicates (crashes) : C++ Backtraces==
 
 
 
===Definition===
 
 
 
A backtrace is a piece of information that describes what was the application doing when it encountered the error and had to close itself. It is a “function stack” leading to the “crashing point”.
 
 
 
In KDE applications, the backtraces are generated by the Crash Handler Dialog (“DrKonqi”). They can also be generated by the general debugger “GDB”, but that involves more steps.
 
 
 
The backtrace is read from top to bottom. The first line shows ''where'' the crash occurred (because of an illegal instruction, invalid pointer, memory problem or other issues). The other lines show the “way to the first function”.
 
 
 
===Example===
 
 
 
Application: Plasma Workspace (kdeinit4), signal: Bus error
 
[KCrash Handler]
 
#5  0x00007fb563bb8f02 in KPixmapCache::Private::mmapFile (this=0x92df60,
 
filename=..., info=0x92dfb0, newsize=33656832) at /usr/src/debug/kdelibs-
 
4.4.1/kdeui/util/kpixmapcache.cpp:491
 
#6  0x00007fb563be3c34 in KPixmapCache::Private::mmapFiles (this=0x92df60) at
 
/usr/src/debug/kdelibs-4.4.1/kdeui/util/kpixmapcache.cpp:419
 
#7  0x00007fb563be38e3 in KPixmapCache::Private::init (this=0x92df60) at
 
/usr/src/debug/kdelibs-4.4.1/kdeui/util/kpixmapcache.cpp:1061
 
#8  0x00007fb563be576d in KPixmapCache::discard (this=0x1203ca0) at /usr/src
 
/debug/kdelibs-4.4.1/kdeui/util/kpixmapcache.cpp:1279
 
#9  0x00007fb563be5e48 in KPixmapCache::deleteCache (name=...) at /usr/src
 
/debug/kdelibs-4.4.1/kdeui/util/kpixmapcache.cpp:1255
 
#10 0x00007fb55afdc97d in Plasma::ThemePrivate::discardCache (this=0x7a7d30)
 
at /usr/src/debug/kdelibs-4.4.1/plasma/theme.cpp:224
 
#11 0x00007fb55afe009b in Plasma::ThemePrivate::setThemeName (this=0x7a7d30,
 
tempThemeName=<value optimized out>, writeSettings=<value optimized out>)
 
at /usr/src/debug/kdelibs-4.4.1/plasma/theme.cpp:380
 
#12 0x00007fb55afe19fb in Plasma::Theme::settingsChanged (this=0x70af20) at
 
/usr/src/debug/kdelibs-4.4.1/plasma/theme.cpp:341
 
#13 0x00007fb55afe2918 in Plasma::ThemePrivate::settingsFileChanged
 
(this=0x7a7d30, file=<value optimized out>) at /usr/src/debug/kdelibs-
 
4.4.1/plasma/theme.cpp:335
 
...
 
 
 
===Description of a backtrace line===
 
 
 
#NumberInTheStack MemoryAddress in Namespace::Class:FunctionMember
 
(argumentThis=pointerValue, argument1=value, argument2=value, ...) at path/to
 
/source/code/file.cpp:linenumber
 
 
 
* #NumberInTheStack: is the order number in the function stack. The lesser, the nearer to the crash point. The smaller number may not be zero
 
* MemoryAddress: we don't put attention to this one.. Ignore
 
* Namespace: C++ namespace of the function. It may not be available if there are no namespaces. This could be also a class name if "Class" is an embedded one.
 
* Class: C++ class name of the function
 
* FunctionMember: C++ function name
 
* argumentThis=pointerValue : this first argument is often the memory address/pointer of the C++ object (example "this=0x91ec5f8"

other argument use the same form "parameterName=parameterValue"
 
* (..): arguments supplied to the function. This information may not be available if *debug information* is not present


 
* path/to/source/code/file.cpp:linenumber the path to the source code file that describes that function, and the line number. The path is the one found at '''build time'''. This information may not be useful if '''debug information''' is not available (in that case, the name of the library or application binary may be included. Example: ''/home/kde-devel/kde/lib/libsopranoclient.so.1'')
 
 
 
'''Example''':
 
 
 
#13 0xb759d5d7 in Nepomuk::ResourceData::determineUri (this=0x91ec5f8) at
 
/home/kde-devel/kde/src/KDE/kdelibs/nepomuk/core/resourcedata.cpp:671
 
 
 
* The function is the number 13 in the stack
 
* Function's namespace: "Nepomuk"
 
* Function's class: "ResourceData"
 
* Function's function: "determineUri"
 
* The object "Nepomuk::ResourceData" which called to "determineUri" has the pointer "0x91ec5f8"
 
* The function is described (where it was build) at "/home/kde-devel/kde/src/KDE/kdelibs/nepomuk/core/resourcedata.cpp". It leads to the next function in the stack at the line number 671
 
 
 
===Identifying the first (useful) backtrace functions===
 
 
 
The first thing you need to do is to locate where it crashed, identifying the "[KCrash Handler]" mark (only in backtraces fetched using DrKonqi)
 
 
 
If the application only had one thread, then it is at the top of the unique thread; otherwise you may need to look at all the thread (the KCrash mark may not be always in the Thread number 1)
 
 
 
Once that you located the "crashing thread start", pickup the first two or three "ClassName::Functions" pairs from top to bottom (some functions should be ignored, read below)
 
 
 
This pairs will be used as "keywords" for the duplicate search
 
  
{{Note|This is only a general rule. There are some special cases when the first three function at the top may be the same but the crash may be different (specially on complex application/libraries as Konqueror)}}
+
== Identify duplicates ==
 +
As KDE has so many users, we get a lot of reports about bugs which have already been reported (duplicates). Before putting any effort in the current report, check for an existing report. If you find a pre-existing bug report describing the same issue, mark this one as a duplicate of it.
  
If the first backtrace functions aren't available (they are not there, or there are "??") then we can't proceed without [[#Check_the_report_quality_.28and_ask_for_missing_information.29|asking for more information]] (a more complete backtrace).
+
Please see [[Guidelines_and_HOWTOs/Bug_triaging/Identifying_duplicates|the article on identifying duplicates]].
  
===Avoiding useless function calls===
+
== Identify bugs caused by external issues (UPSTREAM/DOWNSTREAM) ==
 +
Not all real bugs affecting KDE software are actually caused by a fault in KDE software. The issue may be "upstream" or "downstream" of KDE.
  
Some functions or calls are common to a lot of applications using the same core libraries (like the Qt library, glib, glibc, or many others). This kind of functions should not be used for search as they are not representative of the crash itself and it may return lots of results.
+
"Upstream" means that the problem lies in an underlying technology that KDE software uses (e.g. Qt, X11, the Linux kernel). Others who make use of KDE software (e.g Linux distributions, 3rd party Plasma plugins) are '''downstream''' of KDE.
  
'''Classes and functions to ignore in a backtrace''':
+
Examples of Upstream issues:
* Kernel/GLibC functions (<tt>__kernel_vsyscall</tt>, <tt>raise</tt>, <tt>abort</tt>)
+
* KDE app experiences a new behavioral issue after upgrading to a newer version of Qt
* Functions from core/base libraries (libraries with filenames like <tt>libpthread.so.0</tt>, <tt>libc.so</tt>, <tt>libstdc++.so</tt>, <tt>libglib-2.0.so</tt>; or functions starting with "*__GI_"). You may also need to ignore calls to graphics drivers (like nvidia or libGL)
+
* KDE app crashes in QtQuick
* Qt containers classes (<tt>QMap</tt>, <tt>QList</tt>, <tt>QLinkedList</tt>, <tt>QVector</tt>, <tt>QStack</tt>, <tt>QQueue</tt>, <tt>QSet</tt>, <tt>QMap</tt>, <tt>QMultiMap</tt>, <tt>QHash</tt>, <tt>QMultiHash</tt>)
+
* KDE app experiences an issue, but only when using the proprietary NVIDIA driver
* Qt deep core classes (<tt>QApplication</tt>, <tt>QCoreApplication</tt>, <tt>QBasicAtomicInt</tt>, <tt>QBasicAtomicPointer</tt>, <tt>QAtomicInt</tt>, <tt>QAtomicPointer</tt>, <tt>QMetaObject</tt>, <tt>QPointer</tt>, <tt>QWeakPointer</tt>, <tt>QSharedPointer</tt>, <tt>QScopedPointer</tt>, <tt>QMetaCallEvent</tt>)
 
* Qt misc functions (<tt>qt_message_output</tt>, <tt>qt_message</tt>, <tt>qGetPtrHelper</tt>, functions starting with <tt>qt_meta_</tt>)
 
  
===Special cases (Advanced)===
 
  
There are special crashes related to the X11 graphics server. To identify this crashes you can search for the "XIOError" function name (often on Thread 1). The "[KCrash handler]" mark appears in a secondary thread.
+
Examples of Downstream issues:
  
The important things to identify those crashes is recognizing the functions *below* the XIOError call (this is, which functions caused the X11 error).
+
* A KDE app crashes because a dependent package is not automatically installed by the user's distro
 +
* Fonts are really hard to read, but only in certain distros
 +
* Graphical corruption with a Plasma theme downloaded from store.kde.org
  
In most of this crashes the functions below "[KCrash handler]" are not important (but they could still be useful to search for duplicates).
+
== Ask for any missing information ==
 +
Now that you know that the bug report is unique and that it is not an external issue, you need to check that all the needed information is there.
  
==Bugs caused by external issues (UPSTREAM/DOWNSTREAM)==
+
* If the reporter has not entered the Platform correctly (i.e., it is "unspecified/Linux"), then ask which platform/distro they are using. This can help determine if there are distro/downstream bugs. Mark the bug as NEEDSINFO/WAITINGFORINFO.
 +
* If the description is not written in English and you cannot understand it, you may want to ask other KDE contributors to translate it for you. Alternatively, you can ask the reporter to use some online translation system.
 +
* If the reporter has not indicated what versions of KDE Plasma, Qt, and KDE Frameworks they are using, ask them to provide that information. ([[Get Involved/Bug Reporting#Software_versions]])
 +
* If the explanation is not clear enough, ask for clarification and concrete steps to reproduce. ([[Get Involved/Bug Reporting#Steps to Reproduce]])
 +
* If the issue is hard to picture without a visual aid and there are no screenshots or a screen recording attached, ask for one. ([[Get Involved/Bug Reporting#Screenshots and screen recordings]])
 +
* If the bug report is about a crash and the backtrace information is incomplete, ask the user to install the missing debug symbols package, reproduce the bug, and generate a new backtrace. ([[Guidelines and HOWTOs/Debugging/How to create useful crash reports]])
  
Check if the bug is caused by an external plugin/add-on or distribution issue
 
  
There are several bugs which may be caused by external add-ons. If you are sure this is the case, you should dismiss the report, telling the reporter to file a new bug in a different place.
+
{{Note| After asking for further information, mark the report as "NEEDSINFO" with resolution "WAITINGFORINFO" (or resolution "BACKTRACE" if you are waiting for a complete backtrace).}}
  
* Applications which use plugins may be easier to affect (like Plasma when using custom Plasmoids/widgets)
+
== Reproduce the bug ==
 +
At this point, the bug report enough is complete enough that you should use the information provided by the reporter and try to make the bug appear on your own system.
  
Distributions can also bring some trouble, specially with packaging.
+
{{Note|It is important to have up-to-date KDE components installed to test bugs. Only try to reproduce bugs using the latest versions of KDE software, or even development versions.}}
  
Some problems that may cause bugs are:
+
{{Warning|Testing bug reports may modify/alter your own desktop configuration; also, to try to reproduce some bugs you may need a clean pristine (or slightly modified) environment. We recommend you to perform tests on a separate KDE installation or a clean user. There is also a way to start KDE applications with a clean configuration, even under your current configuration (setting the KDEDIR environment variable at run-time to an empty directory).}}
* different versions among KDE packages (kdelibs at one version, kdebase at a different one)
 
* missing plugins (broken packaging) causing crashes or missing features.
 
 
 
Also, distribution can include their own add-ons (to bring their own branding or any other special function). If you know KDE software enough you may be able to recognize these unofficial add-ons.
 
 
 
If the reporter mentions an application or dialog you cannot identify, you could try requesting a screenshot; other people may identify if it is a KDE application or an external addition.
 
 
 
{{Note|The '''UPSTREAM''' resolution refers to bugs caused by libraries/dependencies, upstream in the software stack (like Qt, glibc, X11).
 
The '''DOWNSTREAM''' resolution refers to bug caused by the Distributions (broken packaging, ...) or by external plugins (unofficial Plasma widgets, other extensions, ...)}}
 
 
 
==Check the report quality (and ask for missing information)==
 
 
 
Now that you know that the bug report is unique, and that is not an external issue,  you need to check all the needed information is there.
 
 
 
* Check that report is English and that is easily understandable.


 
** If it is not in English you may want to look for someone on the KDE group (IRC channels) that may translate it for you. Alternatively you can ask the reporter to use some online translation system (you won't get a clear explanation, but it is something).
 
** 

If the explanation is not clear enough, and you think that the bug could be described in a image, you may want to ask for a screenshot [explanation of Bugzilla attachments]
 
 
 
* If the bug is a graphical glitch or issue, you may want to request a screenshot [explanation of Bugzilla attachments]
 
* If the issue involves any other component (like the graphics card or drivers) you may need to ask for the versions and component's names
 
* If the bug report is about a crash and the backtrace information is not really complete (and you couldn't perform a duplicate search) you need to ask the user to install the missing debug package symbols, reproduce the bug and generate a new backtrace. Template for this request:
 
 
If you can reproduce the crash at will (or you experience this regularly),
 
can you install the "PACKAGENAME" package and post a complete backtrace here?
 
(you can get more information at http://techbase.kde.org/User:DarioAndres
 
/Basic_Guide_about_Crash_Reporting ) Thanks
 
 
 
The names of the missing packages depends of the application and the distribution (as package naming scheme changes..). Look at List of debug package names on several Distributions
 
 
 
'''Useful information which could be also missing''':
 
* Application version
 
* KDE Platform (and/or Software Compilation) version
 
* If the bug is about a crash, request the version of the Qt library
 
* If the reporter is using an development version, request the Git or SVN revision of the KDE platform and application
 
 
 
{{Note|If you don't get feedback after a period of time, you can mark the report as "NEEDSINFO" with resolution "WAITINGFORINFO" (or resolution "BACKTRACE" if you are waiting for a complete backtrace)}}
 
 
 
==Setting Bugzilla fields (and re-assignation)==
 
 
 
Often the bug reports aren't properly categorized, or they miss some information in the Bugzilla fields (which are useful for sorting and filtering):
 
 
 
* '''Version''': if the report has an application version, you need to set the version in the Bugzilla field. Ideally the version field should reflect the latest version the bug is reproducible with, and of course the other information in the bug (backtrace, description) should also reflect that same version. In the process of triaging old bug reports the version field is a good indicator for a bug that needs newer information.
 
** If the version is missing in the list, please contact the software maintainer or the KDE bugzilla admins to add the version in the system.
 
* '''Priority''': we don't use this field in the KDE bug tracker. The priority is used by the developers to organize their work, it should stay at normal and only changed by the developers of the project.
 
* '''Severity''': If you are not really sure if a report describes a real bug or a feature; or if you cannot diagnose the issue, you need to ask in the support channels or wait for other triagers or developers to check the report.
 
** some hints about the various severity options:
 
*** Critical: The software causes you to lose data.
 
*** Grave: The software is basically unusable now.
 
*** Major: A major feature is broken.
 
*** Crash: The software crashes or hangs.
 
*** Normal: It's a bug that should be fixed.
 
*** Minor: minor loss of function, and there is an easy workaround.
 
*** Wishlist: Request for a new feature or enhancement.
 
* '''Platform''': this field is only important if the bug is related to one distribution or specific system. (most of the bug reports are common to most of the platforms). Same with the OS field
 
 
 
===Renaming a report: Updating the summary===
 
 
 
Most of the times, the reporter user initially sets the bug report's title, and therefore, the summary doesn't really represent the bug itself. You may want to update the title to contain enough information to identify the issue properly.
 
 
 
A good title may contain:
 
 
 
* A brief explanation of the root cause (if it was found)
 
* Some of the symptoms people are experiencing
 
* Additional comments between round brackets/parentheses
 
 
 
{{Tip|Try to use complete and easily readable english sentences as summary}}
 
 
 
* If the bug is about a crash, you may add the first useful ClassName::FunctionName pairs that identify it. You can put them inside square brackets at the end of the title
 
 
 
* If the report has additional information (like a testcase file, or an attached proposed patch) you may add those references as tags at the start of the summary (inside square brackets)
 
 
 
'''Examples''':
 
 
 
[patch] Plasma clock draws garbage when hovering it if the Ctrl key is pressed
 
 
 
Dolphin hangs when trying to view the properties of a big file
 
 
 
[testcase file] Plasma crashes when adding a special file to the panel
 
[Class1::Function1, Class1::Function2, Class2::Function3]
 
 
 
Applications that use Plasma themes crash when compositing is switched on/off
 
due an error in KPixmapCache [KPixmapCache::Private::mmapFile,
 
KPixmapCache::Private::init, KPixmapCache::discard]
 
 
 
[testcase url] Konqueror shows a graphical artifact in webpage's form when
 
scrolling
 
 
 
===Reassigning bug reports===
 
 
 
Some of the reports are assigned to the wrong product. This may happen because the original reporter didn't know to which application/library did the bug belong to. It may happen if the Crash Handler dialog reports a crash about an unsupported application (or one that is not mapped properly)
 
 
 
{{Warning|Only perform re-assignations if you are sure the bug is in the wrong product.}}
 
 
 
{{Note|Remember to check the [http://techbase.kde.org/Contribute/Bugsquad/Guide_To_BugTriaging#List_of_related_KDE_technologies KDE related technologies list]}}
 
 
 
# Select the correct Bugzilla product.
 
# If you are sure the current assignee is the default of the current product, you need to click the checkbox to reset the assignee (so the assignee of the new(and correct) Bugzilla product will get notified)
 
# Commit the changes
 
# In the next page, select the correct Component and Version, and save the changes
 
 
 
==Adding related people to the CC list==
 
 
 
Sometimes, the reports describe general issues or are filed against common bugzilla products (like "kde" or "kdelibs"); or, on the other round, are filed against specific products (but the underling bug root cause is at some specific library, not directly related to the current bugzilla product assignee)
 
 
 
In both cases, if we don't need/want to reassign the report (because we aren't really sure about it), we can add the assignee of the other related products, or other developers mail address, to the CC list of the bug report.
 
That means, this person (or people following a mailing list) will get notified about this bug report, and they might look at it.
 
 
 
To know whom to add to the CC list you can:
 
* Look at the [https://bugs.kde.org/editproducts.cgi list of bugzilla products and components] and find the current default assignee (this requires special "editcomponents" permissions)
 
* Look at copyright of the source code related to the bug. (You can always access the code using [http://websvn.kde.org/trunk/KDE/ WebSVN])
 
* Ask in the IRC support channels which person is related to an specific KDE area (#kde-devel)
 
 
 
Common situation '''examples''':
 
 
 
* A report against "Dolphin" describes a Nepomuk-related error.
 
** Add the Nepomuk default assignee to the CC list
 
 
 
* A report against "Plasma" describes an error which seems to be more general (at kdelibs level), but you are not really sure if you should reassign it.
 
** Do not reassign and add "kdelibs-bugs___at___kde___dot___org" to the CC list
 
 
 
* A report against the "kde" bugzilla product describes a Konqueror-related issue (and you aren't sure it is a Konqueror-only issue)
 
** Do not reassign and add "konq-bugs___at___kde___dot___org" to the CC list
 
 
 
* A report against the "kde" bugzilla product describes a Plasma issue
 
** Reassign the report to the "plasma" bugzilla product; or
 
** Add "plasma-bugs___at___kde___dot___org" to the CC list
 
 
 
==Other Situations and Cases==
 
 
 
===One report per issue===
 
 
 
There is a policy in KDE bugtracker which establishes that different issues/bugs should not be mixed up in the same bug report, in order to keep the database clean and easy to read.
 
 
 
If any user adds information which is unrelated to the current bug report, gently tell him/her to write it down on a *different/new report. (The new issue described may be already reported somewhere else. In that case, you need to write a reference to the that bug report ID)
 
 
 
=Trying to reproduce the bugs=
 
 
 
An important step of bug triaging is trying to reproduce the bugs, this means, using the information the reporters added to the bug report to force(recreate, reproduce, repeat) the bug in the application.
 
 
 
This is needed in order to differentiate random/race condition bugs of reproducible ones (which may be reproduced by developers too; and they can fix them)
 
 
 
{{Warning|Testing bug reports may modify/alter your own desktop configuration; also, to try to reproduce some bugs you may need a clean pristine (or sightly modified) environment. I recommend you to perform tests on a separate KDE installation or a clean user. There is also a way to start KDE applications with a clean configuration, even under your current configuration (setting the KDEDIR environment variable at run-time to an empty directory).}}
 
  
 
You may want to use this reference text to setup your testing environment: [http://forum.kde.org/viewtopic.php?f=9&t=84475 Preparing a testing environment]
 
You may want to use this reference text to setup your testing environment: [http://forum.kde.org/viewtopic.php?f=9&t=84475 Preparing a testing environment]
  
{{Note|It is also important to have an updated KDE SC installation to test bugs.}}
+
If you can't reproduce with any scenario mentioned in the comments, you may want to try other related situations. Write down any newly discovered steps to reproduce.
 
 
==How to test bug reproducibility==
 
 
 
# Read the *complete* bug report (including all the attached information). Note that some bits of information may look unrelated; but they could be useful (or not)
 
# Use the information in the first comment (the original bug description) to try to reproduce the bug in the application.
 
# If you can reproduce the bug, then go to the next step
 
#* If you can't reproduce the bug, use the next comment in the report (which may add new information) to try to reproduce.
 
#* If you can't reproduce with all the comments in a separate way, you may want to try combined situations (a bit of the description of the original bug, plus a bit of the second one) and similar combinations. You often have to use your imagination a bit (hopefully we still have time). Hopefully, you may find a combination that may reproduce the bug all (or most of) the times. Write down the "recipe" (steps to reproduce it), you need to include that data into the report later.
 
# Now that we have a result, we need to add our information/conclusions to the bug report
 
 
 
{{Tip|When trying to reproduce a bug, and if there are more than one piece of information, at first glance, try to identify a *common situation*. (some data or context that is present in all (or most of) the cases). This kind of data may be the key to find out how to reproduce.}}
 
 
 
==Adding new information (and requesting feedback)==
 
 
 
* In any case, add your KDE SC version and system information. (other kind of configuration data may be useful to: "did you tested it on a clean environment or in your existing configuration ?"  "do you have library X installed and updated ?" "is your system 32 or 64 bits ?")
 
 
 
'''If you could reproduce the bug''':
 
 
* If you had to combine several steps to make your own "recipe" to reproduce, write it down. This kind of information should be useful for the developers.
 
 
* If you had to use custom input data (text, or a file); you may want to attach it to the bug report (of course, if it is not attached already)
 
 
 
A template of a comment for this situation could be:
 
 
 
I can reproduce the bug here using KDE SC x.y.z, Qt a.b.c on Distribution,
 
Kernel d.e.f on XX bits.
 
In order to reproduce I have to perform the following actions:
 
1- Action 1
 
2- Action 2
 
3- Action 3
 
4- Bug Appears
 
Note that you need to have the X configuration set to Y, and use the Z library
 
- Can anyone else confirm this ?
 
Thanks
 
 
 
'''If you could not reproduce the bug''':
 
 
* Write down which kind of steps you performed to try to get the bug.
 
 
 
* You may want to ask to all the reporters if your step had missing something, or if they notice any other strange (or not-default) situation or configuration which may be related.
 
 
 
* Also, if the report is a bit old (more than two major KDE SC releases old), you could try to ask the reporters if you can reproduce the bug in the latest stable KDE SC release or trunk (development version). The bug may be fixed already (but no one wrote it down into the bug report). If a comment indicates that the bug is resolved, close the bug as WORKSFORME, and refer to the comment in which the reporter indicated being unable to reproduce.
 
 
 
A template of comment for this situation could be:
 
 
 
I couldn't reproduce the bug here using KDE SC x.y.z, Qt a.b.c
 
on Distribution, Kernel d.e.f on XX bits.
 
I tried performing this actions:
 
1- Action 1
 
2- Action 2
 
or
 
1a- Action 1a
 
2a- Action 2a
 
However the bug didn't appear/the application didn't crash
 
- Are you all using library X and this kind of configuration ?
 
- Can you still reproduce this bug with an updated KDE SC version ?
 
Thanks
 
 
 
Hopefully you will get feedback from the reporters and you could gather more information to try to reproduce the bug or close the report as WORKSFORME (or FIXED)
 
 
 
=Getting bug triaging support=
 
 
 
During your work you may need help on how to proceed, you can use this resources to get help:
 
  
* The '''#kde-bugs channel''' on IRC (Freenode.net). You can ask to the whole channel.
+
=== If you cannot reproduce the bug under any circumstances ===
* The BugSquad mailing list <bugsquad ##at## kde ##dot## org>
+
Write down the steps you performed. Ask the reporter if your steps missed something, or if anyone notices any other strange or non-default situation or configuration which may be related. Also ask the reporter for more information and mark it NEEDSINFO/WAITINGFORINFO.
  
=BugWeeks=
+
Hopefully, you will get feedback from the reporters and you could gather more information to try to reproduce the bug or close the report as RESOLVED/WORKSFORME (or FIXED) after a short wait.
  
We are planing to host bug triaging events (where new "students" can learn the tricks) named "BugWeeks" on a regular basis to help cleaning up the KDE bug tracker database.
+
=== If you can reproduce the bug ===
 +
If you had to combine several steps to make your own "recipe" to reproduce, write them down. This kind of information is useful for the developers. If you had to use custom input data (text, or a file), you may want to attach it to the bug report. Don't forget to mention the environment and circumstances under which you can reproduce the bug.  
  
The BugWeeks initiative is based on the Klassroom initiative in the KDE Community Forums
+
== Set Bugzilla fields ==
 +
Often a bug report isn't properly categorized, or lacks some information in the Bugzilla fields (which are useful for sorting and filtering). If a field isn't mentioned below, you don't need to change it. All users have permission to change most Bugzilla fields.
  
You can find more information about this at:
+
=== Product ===
* [http://forum.kde.org/viewtopic.php?f=4&t=84473 BugWeeks announcement]
+
Many bug reports are reported against the wrong product. This may happen because the original reporter didn't know which application/library the bug belongs to. For example, many bugs filed to Dolphin are actually about KIO (the I/O framework) or Baloo (the search frameworks). Remember to check the [[Guidelines_and_HOWTOs/Bug_triaging/Identifying_duplicates#List_of_related_KDE_technologies|KDE related technologies list]].
* [http://forum.kde.org/viewforum.php?f=148 BugWeeks subsection on KDE Community Forums]
 
* [http://forum.kde.org/viewtopic.php?f=148&t=84713 BugWeek 0 - Plasma Desktop bugs] ([http://forum.kde.org/viewtopic.php?f=148&t=84888 Summary])
 
  
=FAQ=
+
{{Warning|Only reassign if you are sure the bug is in the wrong product.}}
=More Information=
+
=== Component ===
 +
As with the Product field, many bug reports are reported against the wrong component or none at all. Set the Component if you are able to determine a more appropriate one than the bug's current assignment.
  
==List of related KDE technologies==
+
=== Version===
 +
If the report has an application version, you need to set the version in the Bugzilla field. Ideally the version field should reflect the latest version the bug is reproducible with. If the version is missing from the list, please contact the software maintainer or the KDE Bugzilla admins to add the version.
  
* Every KDE application use kdelibs [Bugzilla product: '''"kdelibs"''']
+
=== Platform  ===
* Applications using the standard KDE file operations use KIO [Bugzilla product: '''"kio"'''] and probably KFile (for the UI part) [Bugzilla product: '''"kfile"''']
+
This field is only important if the bug is related to one distribution or a specific system (the majority of bug reports are common to most platforms).
* Oxygen widget style (default) [Bugzilla product: '''"oxygen"''' component '''"style"'''] (I'm adding the component because "Oxygen" also refers to a Plasma and icon themes)
 
* Multimedia usage: Phonon library [Bugzilla product: '''"Phonon"''']
 
* PIM related applications use kdepimlibs, Akonadi and kresources technologies [Bugzilla products: '''"kdepim"''', '''"kdepimlibs"''', '''"Akonadi"''', '''"kresources"''']
 
* Applications using KHTML [Bugzilla product: '''konqueror"''']
 
* Applications using OpenDesktop services uses Attica [Bugzilla product: '''"attica"''']
 
* Screen management related operations use the Kephal subsystem [Bugzilla product: '''"kephal"''']
 
* Games use libkdegames [Bugzilla product: '''"libkdegames"''']
 
* Scanning related applications probably use the KSane lib [Bugzilla product: '''"libksane"''']
 
* Multimedia applications reading audio tags use taglib [Bugzilla product: '''"taglib"''']
 
* Hardware related functions use Solid classes [Bugzilla product: '''"solid"''']
 
* Power Management functions use PowerDevil [Bugzilla product: '''"solid"''', component: '''"powerdevil-daemon"''']
 
  
==Special products and cases==
+
=== Severity ===
 +
Mark the bug's severity. Some hints about the various severity options:
 +
* '''Critical''': A widespread, easily reproducible issue that causes data loss.
 +
* '''Grave''': The software is basically unusable, with no workaround.
 +
* '''Major''': A major feature is broken, and the workaround (if any) is painful and difficult.
 +
* '''Crash''': The software crashes or hangs.
 +
* '''Normal''': It's a bug that should be fixed, possibly with a reasonable workaround.
 +
* '''Minor''': Minor cosmetic issue or loss of function with an easy workaround.
 +
* '''Wishlist''': Request for a new feature or enhancement.
  
* "systemsettings" contain bug reports of the Shell application SystemSettings and kcmshell4, and reports of the configuration modules "kcm_*"
+
=== Keywords ===
** Try to identificate if the report is about the shell applications (and set the component to "general", "treeview" or "kcmshell") or about some of the configuration modules (and set the component to "kcm_*name*")
+
If the bug seems like it would be really easy to fix, add the "junior-jobs" keyword. Examples of issues that would be easy to fix:
 +
* Inaccurate description or text label
 +
* Visual layout inconsistencies
 +
* Pixellated icons when an app is run in HiDPI mode
 +
* User interface element is the wrong color when using Breeze Dark
  
* Konqueror can use different engines, like KHTML or WebKit
+
New code contributors often start with "junior-jobs" bugs, so ensuring that there is a steady supply of bugs tagged with this keyword helps them get started with small, manageable tasks.
** If the report is about a webkit-only issue, reassign to product "kdelibs", component "kdewebkit"
 
  
{{Tip|When updating the bugzilla product or component, do not forget to reset to the default assignee}}
+
If the bug involves a poor user interface or demands a tedious workflow, tag it with the "usability" keyword, and it will be considered a part of KDE's [https://phabricator.kde.org/T6831|"Usability & productivity" initiative].
  
==Useful Links==
+
=== Status ===
 +
If you can reproduce the issue, ''and you are confident that you have set all fields correctly'', set the bug report's status to CONFIRMED. This only applies to bugs; feature requests ("wishlist" items) don't need to be confirmed, since they're not bugs.
  
* [http://techbase.kde.org/Contribute/Bugsquad BugSquad page on Techbase]
+
== Rename the bug report ==
* [http://techbase.kde.org/Contribute/Bugsquad/Quick_Introduction_to_Bugzilla Quick introduction to Bugzilla]
+
The bug report's summary might not accurately represent the bug, especially after you have triaged the bug and found the root cause or determined it to be another issue. You may want to update the summary to contain enough information to identify the issue properly. A good summary:
* [https://darioandreskde.wordpress.com/ Dario_Andres blog about bug triaging]
 
* [https://bugs.kde.org/page.cgi?id=fields.html A Bug's Life Cycle]
 
* [http://forum.kde.org/viewtopic.php?f=9&t=84475 Preparing a testing environment]
 
* [http://techbase.kde.org/Contribute/Bugsquad/How_to_create_useful_crash_reports How to create useful crash reports]
 
* [http://techbase.kde.org/User:DarioAndres/Basic_Guide_about_Crash_Reporting Basic guide about crash reports]
 
* [http://aseigo.blogspot.com/2009/01/bugskdeorg.html aseigo's suggestions for bugs.kde.org]
 
  
==Debug package names for several distributions==
+
* Is readable as a grammatically correct English sentence
 +
* Contains a brief explanation of the root cause (if it was found)
 +
* Includes some of the symptoms people are experiencing
 +
* Includes <tt>ClassName::FunctionName</tt> pairs if the bug describes a crash
 +
* Isn't too long
  
For every KDE application it is recommended to install the debug information for "kdelibs" and "qt4"
+
= Special circumstances =
 +
=== Bug describes multiple issues ===
 +
You must close the bug report as RESOLVED/NOT A BUG with a '''humane''' explanation that bug reports can only contain a single issue. ([[Get Involved/Bug Reporting#One issue per bug report]])
  
{| class="wikitable" style="border:1px solid #AAA; padding:2px"
+
=== Bug includes a patch ===
|-
+
If the bug reporter or someone else included a patch, ask them to submit it using Phabricator, and remind them about [[Get Involved/Bug Reporting#Submit patches using Phabricator.2C not the bug tracker]].
!  Package
 
!  Ubuntu/Debian
 
!  OpenSuse
 
!  Fedora
 
!  Mandriva
 
|-
 
|  ''kdelibs''
 
|  kdelibs5-dbg
 
|  kdelibs4-debuginfo
 
|  kdelibs-debuginfo
 
|  kdelibs4-debug
 
|-
 
|  ''qt''
 
|  libqt4-dbg
 
|  libqt4-debuginfo
 
|  qt-debuginfo
 
|  qt4-debug
 
|-
 
|  ''kdebase (KDE base applications)''
 
|  kdebase-dbg, kdebase-runtime-dbg, kdebase-workspace-dbg
 
|  kdebase4-debuginfo, kdebase4-runtime-debuginfo, kdebase4-workspace-debuginfo
 
|  kdebase-debuginfo, kdebase-runtime-debuginfo, kdebase-workspace-debuginfo
 
|  kdebase4-debug, kdebase4-runtime-debug, kdebase4-workspace-debug
 
|-
 
|  ''General example for every KDE "MODULE"''
 
|  kdeMODULE-dbg
 
|  kdeMODULE4-debuginfo
 
|  kdeMODULE-debuginfo
 
|  kdeMODULE4-debug
 
|-
 
|  ''Phonon (multimedia subsystem)''
 
|  phonon-dbg
 
|  libphonon4-debuginfo / phonon4-debuginfo
 
|  phonon-debuginfo
 
|  phonon-debug
 
|}
 
  
For a detailed list of distributions naming scheme examples you can look at [http://techbase.kde.org/index.php?title=User:DarioAndres/CreateUsefulReports#How_to_obtain_debug_package_for_several_distributions How to obtain debug packages for every distribution].
+
=== Reporter seems very technically knowledgeable ===
 +
Sometimes a very technically knowledgeable bug reporter will correctly identify the source of the issue, and maybe even the exact line of code that's causing the problem. Encourage them to submit a patch, and point them to https://community.kde.org/Get_Involved/development.
  
==Glossary==
+
=== Same person reports a lot of bugs ===
 +
Anybody who reports a lot of KDE bugs--especially if they are high quality bugs--is quite likely a committed KDE user who is a good candidate for becoming a more involved contributor over time. '''Stumbling on someone like this in the bug tracker is like striking gold.''' Take every opportunity to develop a relationship with this person and try to guide them through the KDE "[[Get Involved|get involved]]" pipeline. Oftentimes people who submit a lot of bugs move on to bug triaging and then later development.
  
* Testcase: custom file that triggers a bug in the application. A testcase can also be a custom code snippet, or to a set of steps.
+
= Policies =
 +
* Bugs placed into NEEDSINFO status will receive a reminder if the ticket:
 +
** Is at least 15 days old
 +
** Has not received any comment within 15 days
 +
* If a bug remains in NEEDSINFO for another 15 days with no comment, it will be closed as RESOLVED > WORKSFORME.
 +
* If a bug remains in NEEDSINFO with a comment provided within less than 15 days, no action will be taken (as it does not meet the above criteria).

Latest revision as of 13:20, 13 November 2019

Help Konqi catch some bugs!

The KDE Bugsquad keeps track of incoming bugs in KDE software, and goes through old bugs. We verify that a bug exists, whether it is reproducible, and that the reporter has given enough information. Our goal is to save developers from doing this, which helps them fix bugs more quickly and do more work on KDE software.

Getting involved in the Bugsquad is a good place to start. An existing member will help you out and mentor you. One of the great things about the Bugsquad and bug triaging is that you do not need any programming knowledge! That said, experience has shown that members of this team learn a lot about KDE and Qt programming during the course of dealing with bug reports, and many move on to developing the software itself. If you are just starting to learn programming, bug triaging is a great way to gain familiarity with the components and give practical support to the KDE community.

For live chat, we have the #kde-bugs IRC channel on Freenode. Please feel free to stop by! You can also connect via Matrix if you prefer.

To join the Bugsquad, become a member of our project on Phabricator. We organize Bug Days, where we focus on a specific product, with the goal of reviewing all open bugs by the end of the day. These meetings occur primarily on #kde-bugs.

We have a Bugsquad calendar you can view or export as ICS to your calendar of choice. The calendar lists all of the upcoming Bug Days and what product we will be focusing on. These days are great times to get involved and ask questions!

General considerations

  • Be polite. Bug triagers are the face of KDE. Be nice to bug reporters, even if they aren't nice to you! You have an opportunity to showcase the best of the KDE community, and turn skeptics into fans. Being nice is more impactful than being right.
  • Explain your decisions. It can be very frustrating for a bug reporter if his/her report is suddenly closed without any reason. Write why you think that your action is the correct one, and don't establish your opinion as the all-ruling fact.
  • Don't be afraid to make mistakes. Everybody does make mistakes, especially when starting out with bug triaging.
  • KDE uses the Bugzilla bug tracker system. If you are not familiar with it, you may find this quick Introduction to Bugzilla useful.
  • The BugzillaJS add-on for Firefox is highly recommended, as it greatly improves the user experience.

Decide what to work on

All bugs filed recently

All bug reports of a single product

You'll want to use the Advanced search for this: https://bugs.kde.org/query.cgi

You can see which products are most in need of bug triaging here, with links to their bug lists: https://bugs.kde.org/weekly-bug-summary.cgi?tops=50&days=7

Here are some common and popular KDE products in need of bug triaging:

Bug editing permissions

All regular Bugzilla users can perform standard editing functions. You can change a number of fields, including the product, component, version, platform, status, and more. You are restricted from only a few abilities, such as bulk editing, changing the Priority and Severity fields (Importance), or re-opening CLOSED bugs. After getting comfortable with the KDE Bugzilla process, you can request "contributor" privileges from Sysadmin, which will allow you to perform those actions.

What to do with bug reports

Now that you have a list of bug reports, pick one and start working! Here is the optimal bug triaging workflow:

DarioAndres GuideToBugTriaging Workflow.png

Note
If at any point you aren't sure how to proceed, move onto the next bug or ask a KDE developer or another more experienced contributor.


Identify duplicates

As KDE has so many users, we get a lot of reports about bugs which have already been reported (duplicates). Before putting any effort in the current report, check for an existing report. If you find a pre-existing bug report describing the same issue, mark this one as a duplicate of it.

Please see the article on identifying duplicates.

Identify bugs caused by external issues (UPSTREAM/DOWNSTREAM)

Not all real bugs affecting KDE software are actually caused by a fault in KDE software. The issue may be "upstream" or "downstream" of KDE.

"Upstream" means that the problem lies in an underlying technology that KDE software uses (e.g. Qt, X11, the Linux kernel). Others who make use of KDE software (e.g Linux distributions, 3rd party Plasma plugins) are downstream of KDE.

Examples of Upstream issues:

  • KDE app experiences a new behavioral issue after upgrading to a newer version of Qt
  • KDE app crashes in QtQuick
  • KDE app experiences an issue, but only when using the proprietary NVIDIA driver


Examples of Downstream issues:

  • A KDE app crashes because a dependent package is not automatically installed by the user's distro
  • Fonts are really hard to read, but only in certain distros
  • Graphical corruption with a Plasma theme downloaded from store.kde.org

Ask for any missing information

Now that you know that the bug report is unique and that it is not an external issue, you need to check that all the needed information is there.

  • If the reporter has not entered the Platform correctly (i.e., it is "unspecified/Linux"), then ask which platform/distro they are using. This can help determine if there are distro/downstream bugs. Mark the bug as NEEDSINFO/WAITINGFORINFO.
  • If the description is not written in English and you cannot understand it, you may want to ask other KDE contributors to translate it for you. Alternatively, you can ask the reporter to use some online translation system.
  • If the reporter has not indicated what versions of KDE Plasma, Qt, and KDE Frameworks they are using, ask them to provide that information. (Get Involved/Bug Reporting#Software_versions)
  • If the explanation is not clear enough, ask for clarification and concrete steps to reproduce. (Get Involved/Bug Reporting#Steps to Reproduce)
  • If the issue is hard to picture without a visual aid and there are no screenshots or a screen recording attached, ask for one. (Get Involved/Bug Reporting#Screenshots and screen recordings)
  • If the bug report is about a crash and the backtrace information is incomplete, ask the user to install the missing debug symbols package, reproduce the bug, and generate a new backtrace. (Guidelines and HOWTOs/Debugging/How to create useful crash reports)


Note
After asking for further information, mark the report as "NEEDSINFO" with resolution "WAITINGFORINFO" (or resolution "BACKTRACE" if you are waiting for a complete backtrace).


Reproduce the bug

At this point, the bug report enough is complete enough that you should use the information provided by the reporter and try to make the bug appear on your own system.

Note
It is important to have up-to-date KDE components installed to test bugs. Only try to reproduce bugs using the latest versions of KDE software, or even development versions.


Warning
Testing bug reports may modify/alter your own desktop configuration; also, to try to reproduce some bugs you may need a clean pristine (or slightly modified) environment. We recommend you to perform tests on a separate KDE installation or a clean user. There is also a way to start KDE applications with a clean configuration, even under your current configuration (setting the KDEDIR environment variable at run-time to an empty directory).


You may want to use this reference text to setup your testing environment: Preparing a testing environment

If you can't reproduce with any scenario mentioned in the comments, you may want to try other related situations. Write down any newly discovered steps to reproduce.

If you cannot reproduce the bug under any circumstances

Write down the steps you performed. Ask the reporter if your steps missed something, or if anyone notices any other strange or non-default situation or configuration which may be related. Also ask the reporter for more information and mark it NEEDSINFO/WAITINGFORINFO.

Hopefully, you will get feedback from the reporters and you could gather more information to try to reproduce the bug or close the report as RESOLVED/WORKSFORME (or FIXED) after a short wait.

If you can reproduce the bug

If you had to combine several steps to make your own "recipe" to reproduce, write them down. This kind of information is useful for the developers. If you had to use custom input data (text, or a file), you may want to attach it to the bug report. Don't forget to mention the environment and circumstances under which you can reproduce the bug.

Set Bugzilla fields

Often a bug report isn't properly categorized, or lacks some information in the Bugzilla fields (which are useful for sorting and filtering). If a field isn't mentioned below, you don't need to change it. All users have permission to change most Bugzilla fields.

Product

Many bug reports are reported against the wrong product. This may happen because the original reporter didn't know which application/library the bug belongs to. For example, many bugs filed to Dolphin are actually about KIO (the I/O framework) or Baloo (the search frameworks). Remember to check the KDE related technologies list.

Warning
Only reassign if you are sure the bug is in the wrong product.

Component

As with the Product field, many bug reports are reported against the wrong component or none at all. Set the Component if you are able to determine a more appropriate one than the bug's current assignment.

Version

If the report has an application version, you need to set the version in the Bugzilla field. Ideally the version field should reflect the latest version the bug is reproducible with. If the version is missing from the list, please contact the software maintainer or the KDE Bugzilla admins to add the version.

Platform

This field is only important if the bug is related to one distribution or a specific system (the majority of bug reports are common to most platforms).

Severity

Mark the bug's severity. Some hints about the various severity options:

  • Critical: A widespread, easily reproducible issue that causes data loss.
  • Grave: The software is basically unusable, with no workaround.
  • Major: A major feature is broken, and the workaround (if any) is painful and difficult.
  • Crash: The software crashes or hangs.
  • Normal: It's a bug that should be fixed, possibly with a reasonable workaround.
  • Minor: Minor cosmetic issue or loss of function with an easy workaround.
  • Wishlist: Request for a new feature or enhancement.

Keywords

If the bug seems like it would be really easy to fix, add the "junior-jobs" keyword. Examples of issues that would be easy to fix:

  • Inaccurate description or text label
  • Visual layout inconsistencies
  • Pixellated icons when an app is run in HiDPI mode
  • User interface element is the wrong color when using Breeze Dark

New code contributors often start with "junior-jobs" bugs, so ensuring that there is a steady supply of bugs tagged with this keyword helps them get started with small, manageable tasks.

If the bug involves a poor user interface or demands a tedious workflow, tag it with the "usability" keyword, and it will be considered a part of KDE's "Usability & productivity" initiative.

Status

If you can reproduce the issue, and you are confident that you have set all fields correctly, set the bug report's status to CONFIRMED. This only applies to bugs; feature requests ("wishlist" items) don't need to be confirmed, since they're not bugs.

Rename the bug report

The bug report's summary might not accurately represent the bug, especially after you have triaged the bug and found the root cause or determined it to be another issue. You may want to update the summary to contain enough information to identify the issue properly. A good summary:

  • Is readable as a grammatically correct English sentence
  • Contains a brief explanation of the root cause (if it was found)
  • Includes some of the symptoms people are experiencing
  • Includes ClassName::FunctionName pairs if the bug describes a crash
  • Isn't too long

Special circumstances

Bug describes multiple issues

You must close the bug report as RESOLVED/NOT A BUG with a humane explanation that bug reports can only contain a single issue. (Get Involved/Bug Reporting#One issue per bug report)

Bug includes a patch

If the bug reporter or someone else included a patch, ask them to submit it using Phabricator, and remind them about Get Involved/Bug Reporting#Submit patches using Phabricator.2C not the bug tracker.

Reporter seems very technically knowledgeable

Sometimes a very technically knowledgeable bug reporter will correctly identify the source of the issue, and maybe even the exact line of code that's causing the problem. Encourage them to submit a patch, and point them to https://community.kde.org/Get_Involved/development.

Same person reports a lot of bugs

Anybody who reports a lot of KDE bugs--especially if they are high quality bugs--is quite likely a committed KDE user who is a good candidate for becoming a more involved contributor over time. Stumbling on someone like this in the bug tracker is like striking gold. Take every opportunity to develop a relationship with this person and try to guide them through the KDE "get involved" pipeline. Oftentimes people who submit a lot of bugs move on to bug triaging and then later development.

Policies

  • Bugs placed into NEEDSINFO status will receive a reminder if the ticket:
    • Is at least 15 days old
    • Has not received any comment within 15 days
  • If a bug remains in NEEDSINFO for another 15 days with no comment, it will be closed as RESOLVED > WORKSFORME.
  • If a bug remains in NEEDSINFO with a comment provided within less than 15 days, no action will be taken (as it does not meet the above criteria).

This page was last edited on 13 November 2019, at 13:20. Content is available under Creative Commons License SA 4.0 unless otherwise noted.
-->