Metrics are the heart of Sonar, using Sonar efficiently means perfectly understanding the definition and calculation algorithm of each one.

Name	Key	Description
Physical lines	lines	Number of carriage returns
Comment lines	comment_lines	Number of javadoc, multi-comment and single-comment lines. Empty comment lines like, header file comments (mainly used to define the license) and commented-out lines of code are not included. ? /**  * This is a javadoc block  *           <- empty comment line considered as a blank line  */          <- empty comment line considered as a blank line /*  * This is a multi-comment block  */ // This is a single-comment block // log("Debug information"); <- commented-out line of code is not a comment line
Commented-out lines of code	commented_out_code_lines	Number of commented-out lines of code. Javadoc blocks are not scanned. ? /* * someoneCommentMeOutOneDay(); * nobodyKnowWhatAmISupposedToDo(); */
Lines of code	ncloc	Number of physical lines of code - number of blank lines - number of comment lines - number of header file comments - commented-out lines of code
Density of comment lines	comment_lines_density	Number of comment lines / (lines of code + number of comments lines) * 100
Packages	packages	Number of packages
Classes	classes	Number of classes including nested classes, interfaces, enums and annotations
Files	files	Number of analyzed files
Directories	directories	Number of analyzed directories
Accessors	accessors	Number of getter and setter methods used to get(reading) or set(writing) a class' property . ? // Getters public String getName(){      return this.name; } public boolean isParent(){      return this.isParent; } // Setters public void setName(String name){      this.name = name; } public void setIsParent(boolean isParent){      this.isParent = isParent; }
Methods	functions	Number of Methods without including accessors. A constructor is considered to be a method.
Public API	public_api	Number of public classes, public methods (without accessors) and public properties (without public final static ones)
Public undocumented API	public_undocumented_api	Number of public API without a Javadoc block
Density of public documented API	public_documented_api_density	(Number of public API - Number of undocumented public API) / Number of public API * 100
Duplicated lines	duplicated_lines	Number of physical lines touched by a duplication
Duplicated blocks	duplicated_blocks	Number of duplicated blocks of lines
Duplicated files	duplicated_files	Number of files involved in a duplication of lines
Density of duplicated lines	duplicated_lines_density	Duplicated lines / Physical lines * 100
Statements	statements	Number of statements as defined in the Java Language Specification but without block definitions. Statements counter gets incremented by one each time an expression, if, else, while, do, for, switch, break, continue, return, throw, synchronized, catch, finally is encountered : ? // i = 0; if (ok) if (exit) { if (3 == 4); if (4 == 4) { ; } } else { try{} while(true){} for(...){} ... Statements counter is not incremented by a class, method, field, annotation definition or by a package and import declaration.
Complexity	complexity	The Cyclomatic Complexity Number is also known as McCabe Metric. It all comes down to simply counting 'if', 'for', 'while' statements etc. in a method. Whenever the control flow of a method splits, the Cyclomatic counter gets incremented by one. Each method has a minimum value of 1 per default except accessors which are not considered as method and so don't increment complexity. For each of the following Java keywords/statements this value gets incremented by one: ? if for while case catch throw return (that isn't the last statement of a method) && || ? Note that else, default, and finally don't increment the CCN value any further. On the other hand, a simple method with a switch statement and a huge block of case statements can have a surprisingly high CCN value (still it has the same value when converting a switch block to an equivalent sequence of if statements). For instance the following method has a complexity of 5 ? public void process(Car myCar){          <- +1     if(myCar.isNotMine()){               <- +1          return;                         <- +1     }     car.paint("red");     car.changeWheel();     while(car.hasGazol() && car.getDriver().isNotStressed()){   <- +2          car.drive();     }     return; }
Average complexity by method	function_complexity	Average cyclomatic complexity number by method
Complexity distribution by method	function_complexity_distribution	Number of methods for given complexities
Average complexity by class	class_complexity	Average cyclomatic complexity by class
Complexity distribution by class	class_complexity_distribution	Number of classes for given complexities
Average complexity by file	file_complexity	Average cyclomatic complexity by file
Violations	violations	Total number of rule violations
New Violations	new_violations	Total number of new violations
xxxxx violations	xxxxx_violations	Number of violations with severity xxxxx, xxxxx being blocker, critical, major, minor or info
New xxxxx violations	new_xxxxx_violations	Number of new violations with severity xxxxx, xxxxx being blocker, critical, major, minor or info
Weighted violations	weighted_violations	Sum of the violations weighted by the coefficient associated at each priority (Sum(xxxxx_violations * xxxxx_weight))
Rules compliance index	violations_density	100 - weighted_violations / Lines of code * 100
Unit tests	tests	Number of unit tests
Unit tests duration	test_execution_time	Time required to execute unit tests
Unit test error	test_errors	Number of unit tests that failed
Unit test failures	test_failures	Number of unit tests that failed with an unexpected exception
Unit test success density	test_success_density	(Unit tests - (errors + failures))/ Unit tests * 100
Skipped unit tests	skipped_tests	Number of skipped unit tests
Line Coverage	line_coverage	On a given line of code, line coverage simply answers the question: "Is this line of code executed during unit test execution?". At project level, this is the density of covered lines: ? Line coverage = LC / EL   where   LC - lines covered (lines_to_cover - uncovered_lines) EL - total number of executable lines (lines_to_cover)
New Line Coverage	new_line_coverage	identical to line_coverage but restricted to new / update source code
Branch coverage	branch_coverage	On each line of code containing some boolean expressions, the branch coverage simply answers the question: "Has each boolean expression evaluated both to true and false ?". At project level, this is the density of possible branches in flow control structures that have been followed. ? Branch coverage = (CT + CF) / (2*B)   where   CT - branches that evaluated to "true" at least once CF - branches that evaluated to "false" at least once (CT + CF = conditions_to_cover - uncovered_conditions)   B - total number of branches (2*B = conditions_to_cover)
New Branch Coverage	new_branch_coverage	identical to branch_coverage but restricted to new / update source code
Coverage	coverage	Coverage metric is a mix of the two previous line coverage and branch coverage metrics to get an even more accurate answer to the question "how much of a source-code is being executed by your unit tests?". The Coverage is calculated with the following formula : ? coverage = (CT + CF + LC)/(2*B + EL)   where   CT - branches that evaluated to "true" at least once CF - branches that evaluated to "false" at least once LC - lines covered (lines_to_cover - uncovered_lines)   B - total number of branches (2*B = conditions_to_cover) EL - total number of executable lines (lines_to_cover)
New Coverage	new_coverage	identical to coverage but restricted to new / update source code
Conditions to Cover	conditions_to_cover	Total number of conditions which could be covered by unit tests.
New Conditions to Cover	new_conditions_to_cover	identical to conditions_to_cover but restricted to new / update source code
Lines to Cover	lines_to_cover	Total number of lines of code which could be covered by unit tests.
New Lines to Cover	new_lines_to_cover	identical to lines_to_cover but restricted to new / update source code
Uncovered Conditions	uncovered_conditions	Total number of conditions which are not covered by unit tests.
New Uncovered Conditions	new_uncovered_conditions	identical to uncovered_conditions but restricted to new / update source code
Uncovered Lines	uncovered_lines	Total number of lines of code which are not covered by unit tests.
New Uncovered Lines	new_uncovered_lines	identical to uncovered_lines but restricted to new / update source code
Depth of inheritance tree	dit	The depth of inheritance tree (DIT) metric provides for each class a measure of the inheritance levels from the object hierarchy top. In Java where all classes inherit Object the minimum value of DIT is 1.
Number of children	noc	A class's number of children (NOC) metric simply measures the number of direct and indirect descendants of the class.
Response for class	rfc	The response set of a class is a set of methods that can potentially be executed in response to a message received by an object of that class. RFC is simply the number of methods in the set.
Afferent couplings	ca	A class's afferent couplings is a measure of how many other classes use the specific class.
Efferent couplings	ce	A class's efferent couplings is a measure of how many different classes are used by the specific class.
Lack of cohesion of methods	lcom4	LCOM4 measures the number of "connected components" in a class. A connected component is a set of related methods and fields. There should be only one such component in each class. If there are 2 or more components, the class should be split into so many smaller classes.
Package cycles	package_cycles	Minimal number of package cycles detected to be able to identify all undesired dependencies.
Package dependencies to cut	package_feedback_edges	Number of package dependencies to cut in order to remove all cycles between packages.
File dependencies to cut	package_tangles	Number of file dependencies to cut in order to remove all cycles between packages.
Package edges weight	package_edges_weight	Total number of file dependencies between packages.
Package tangle index	package_tangle_index	Gives the level of tangle of the packages, best value 0% meaning that there is no cycles and worst value 100% meaning that packages are really tangled. The index is calculated using : 2 * (package_tangles / package_edges_weight) * 100.
File cycles	file_cycles	Minimal number of file cycles detected inside a package to be able to identify all undesired dependencies.
Suspect file dependencies	file_feedback_edges	File dependencies to cut in order to remove cycles between files inside a package. Warning : cycles are not always bad between files inside a package.
File tangle	file_tangles	file_tangles = file_feedback_edges.
File edges weight	file_edges_weight	Total number of file dependencies inside a package.
File tangle index	file_tangle_index	2 * (file_tangles / file_edges_weight) * 100.
Commits	commits	The number of commits
Last commit date	last_commit_date	The latest commit date on a resource
Revision	revision	The latest revision of a resource
Authors by line	authors_by_line	The last committer on each line of code
Revisions by line	revisions_by_line	The revision number on each line of code

From http://docs.codehaus.org/display/SONAR/Metric+definitions

转载于:https://www.cnblogs.com/ericsun/archive/2011/10/17/2215294.html