BatchMetrics (spring-boot-starter-batch-web 1.4.0.RELEASE API)

All Known Implementing Classes:

BatchMetricsImpl
```
public interface BatchMetrics
```
Interface for business metrics. All metric names get the prefix 'batch.{jobName}.{jobExecutionId}.' in addition to other prefixes. For example, when using the counter methods (increment, decrement, reset) the complete prefix will be 'counter.batch.{jobName}.{jobExecutionId}.'. When written to the Step-ExecutionContext, the complete prefix is omitted. There are two types of methods: non-transactional methods and transactional methods. The methods that don't include 'NonTransactional' in their name are by default transaction-aware. That means that their execution is delayed after a successful commit of the current transaction. If there's no current transaction, the method is executed immediately. The non-transactional methods are executed directly, no matter if there's a transaction or not. How do you use this component in a batch environment? You may inject this component into any batch artifact, a reader, processor, writer, a listener and so on. Counter and gauges are held in memory as long as the job runs and will be written to the Step-ExecutionContext once the step finishes, successful or not. They are written to the log file as well. If the job execution is a restart of a previously failed run, the counters are the sum of both executions. Gauges are the ones from the last run. The tricky part is to decide whether the transactional or the non-transactional method should be used for correct counting. This blog post series might help for better understanding how transactions in Spring Batch work: https://blog.codecentric.de/en/2012/03/transactions-in-spring-batch-part-1-the-basics/. The thing is that Spring Batch's transactional behaviour is smart, but gets in your way if you do the metrics in a naive way. When using skip functionality, for example, it may happen that a process - method of a ItemProcessor gets executed several times for one successful processed item, because the item was together in a chunk with a bad item, and the chunk was rolled back. If your counting doesn't get rolled back as well, the metric is wrong. That's why it's so essential to have transactional metrics in Spring Batch. In general you should always use the transactional methods, because when there's no transaction they behave like the non-transactional methods, and when there's a transaction they are only executed when the transaction is successful. However, there are exceptions. With a job configured the default way you have a cache for the read items. When there's a rollback of a chunk, the ItemReader is not re-executed. So for correct countings you have to use the non-transactional methods in the ItemReader and the ItemReadListener. If you set reader-transactional-queue to true for your job, the cache is not used and you have to use the transactional methods in ItemReader and ItemReadListener as well. If you set processor-transactional to false for your job there will be a cache for the processed items as well, so you have to use the non-transactional methods in the ItemProcessor and the ItemProcessListener. And, of course, if you are counting errors in the onError-methods of ItemListeners, you have to use the non-transactional methods because a rollback is going to happen afterwards. If you do a filter in an ItemProcessor you have to use the non-transactional methods, because filtered items are removed from the item cache as well and will never be reprocessed. When using the AsyncItemProcessor there is no filtering possible at all, because a Future-Object is always returned from the ItemProcessor.

Author:

Tobias Flohre

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`decrement(String metricName)` Decrement the specified counter by 1.
`void`	`decrement(String metricName, Long value)` Decrement the specified counter by the given value.
`void`	`decrementNonTransactional(String metricName)` Decrement the specified counter by 1.
`void`	`decrementNonTransactional(String metricName, Long value)` Decrement the specified counter by the given value.
`void`	`increment(String metricName)` Increment the specified counter by 1.
`void`	`increment(String metricName, Long value)` Increment the specified counter by the given value.
`void`	`incrementNonTransactional(String metricName)` Increment the specified counter by 1.
`void`	`incrementNonTransactional(String metricName, Long value)` Increment the specified counter by the given value.
`void`	`reset(String metricName)` Reset the specified counter.
`void`	`resetNonTransactional(String metricName)` Reset the specified counter.
`void`	`submit(String metricName, double value)` Set the specified gauge value.
`void`	`submitNonTransactional(String metricName, double value)` Set the specified gauge value

- Method Detail
  - increment
```
void increment(String metricName)
```
    Increment the specified counter by 1. Transaction-aware.
    
    Parameters:
    metricName - the name of the counter
  - increment
```
void increment(String metricName,
             Long value)
```
    Increment the specified counter by the given value. Transaction-aware.
    
    Parameters:
    metricName - the name of the counter
    value - the amount to increment by
  - decrement
```
void decrement(String metricName)
```
    Decrement the specified counter by 1. Transaction-aware.
    
    Parameters:
    metricName - the name of the counter
  - decrement
```
void decrement(String metricName,
             Long value)
```
    Decrement the specified counter by the given value. Transaction-aware.
    
    Parameters:
    metricName - the name of the counter
    value - the amount to decrement by
  - reset
```
void reset(String metricName)
```
    Reset the specified counter. Transaction-aware.
    
    Parameters:
    metricName - the name of the counter
  - submit
```
void submit(String metricName,
          double value)
```
    Set the specified gauge value. Transaction-aware.
    
    Parameters:
    metricName - the name of the gauge to set
    value - the value of the gauge
  - incrementNonTransactional
```
void incrementNonTransactional(String metricName)
```
    Increment the specified counter by 1.
    
    Parameters:
    metricName - the name of the counter
  - incrementNonTransactional
```
void incrementNonTransactional(String metricName,
                             Long value)
```
    Increment the specified counter by the given value.
    
    Parameters:
    metricName - the name of the counter
    value - the amount to increment by
  - decrementNonTransactional
```
void decrementNonTransactional(String metricName)
```
    Decrement the specified counter by 1.
    
    Parameters:
    metricName - the name of the counter
  - decrementNonTransactional
```
void decrementNonTransactional(String metricName,
                             Long value)
```
    Decrement the specified counter by the given value.
    
    Parameters:
    metricName - the name of the counter
    value - the amount to decrement by
  - resetNonTransactional
```
void resetNonTransactional(String metricName)
```
    Reset the specified counter.
    
    Parameters:
    metricName - the name of the counter
  - submitNonTransactional
```
void submitNonTransactional(String metricName,
                          double value)
```
    Set the specified gauge value
    
    Parameters:
    metricName - the name of the gauge to set
    value - the value of the gauge

Interface BatchMetrics

Method Summary

Method Detail

increment

increment

decrement

decrement

reset

submit

incrementNonTransactional

incrementNonTransactional

decrementNonTransactional

decrementNonTransactional

resetNonTransactional

submitNonTransactional