First, the technical knowledge of project managers varies greatly by the individual. Using metrics related to the technical work done by an engineer will have vastly different interpretations placed upon them depending on who is observing them.

Second, the areas given and why I believe they're not as useful as alleged.

1. Activity Days In the example provided "Activity Days" is measured by the count of lines of code that have been altered. First, this is easily gamed and second it doesn't actually tell you anything other than an engineer is (supposedly) altering code. It also doesn't have any insight into the other responsibilities that an engineer may have during a sprint that have nothing to do with code. I can only imagine a manager's manager looking at this and constantly asking why engineer Ben seems to never be active without ever actually understanding what it is that Ben is really doing day-to-day.

2. Impact To quote the article, "The bigger is the impact the more will be the code and the project affected.[sic]" Impact is not synonymous with risk and risk is far more important to determine. Impact is a small part of the equation one can use it to help determine risk. That said, risk should be determined up front as part of pointing prior to any work being done. If a team can't properly point a piece of work while taking risk into account then the team likely doesn't understand what they're actually trying to do and need to do a research spike.

3. Code Churn The whole point of agile is to iterate and try things. And some of those things will possibly even be thrown away completely. If a team finds itself in a situation where it has iterated the entirety of a two-week sprint on a single piece of functionality then that should be discussed in retro. The discussion should be to determine if the repeated iterations added value or if the team was merely spinning its wheels. This is up to the team to decide not someone who is looking at a "code churn" metric.

4. Work Time Knowing how long engineering takes per work item _as a whole_ is far more valuable than breaking down an engineer's time into the areas described (avg pr time, avg review time, time to open pr). The reason for this is that an engineer's time is only a portion of the overall work done in a sprint for a work item. A team will generally have to do the following steps 1) design 2) engineering 3) quality assurance 4) documentation. Work items often have drastically different time requirements within those steps. A case that may take a day in engineering may require three in quality assurance, vice versa, or three in each.

Now, what should be measured.

Flow. The flow of work items, in a sprint, from start to finish through every step of the way. This requires using points to determine complexity, risk, and other agreed upon concepts (NEVER USE TIME hours, days, etc). Second and even more important, value. This is the most under observed and ignored attribute in agile/scrum or any workflow for that matter. If the product owner can't place a value score on a piece of work then the team should not be doing it. There is nothing more wasteful than producing a piece of functionality for a software product that nobody ends up using. Along with this, there needs to be a way to determine if the value score on a piece of work is accurate as part of a feedback cycle for the product owner and team. (Observing the life of a work item in a released product via usage metrics is one way of achieving this.) When a product owner does this correctly it's amazing to watch. You can't even imagine how ecstatic customers can be when they're constantly bombarded with high-value functionality.

For more information, I would recommend the following reading on this topic.

Start here: https://www.amazon.com/Actionable-Agile-Metrics-Predictabili...

Then go here: https://www.amazon.com/Principles-Product-Development-Flow-G...

Besides what others have commented, I'd like to point some more metrics that help you model your board:

- Task classes.

- Lead time.

- Cycle time.

- Number of backward movements for any list.

- Cumulative card evolution.

There are some good books about this subject:

- David J. Anderson's Kanban (https://www.amazon.com/Kanban-Successful-Evolutionary-Techno...)

- Actionable Agile Metrics for Predictability: An Introduction (https://www.amazon.com/Actionable-Agile-Metrics-Predictabili...)

Shameless plug: checkout my personal project DjangoTrelloStats that measures these metrics for you: https://github.com/diegojromerolopez/django-trello-stats (include a somewhat Trello synchronization tool).