22199895999

Committed 19 Feb 2026 08:56PM UTC coverage: 29.385% (-0.6%) from 30.019%

Build # 22199895999

Build Type

Pull #504

coveralls.net

Committed by

DemoBytom

Commit Message

Switch to source generated logging

Turned on [CA1873](https://learn.microsoft.com/en-us/dotnet/fundamentals/code-analysis/quality-rules/ca1873) as Warning
Refactored all logging instances to use source generated loggers

Pull Request Pull Request #504: Switch to source generated logging

Coverage Stats

640 of 2178 relevant lines covered (29.38%)

0.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.72

/src/Demo.Engine.Core/Services/FpsTimer.cs

// Copyright © Michał Dembski and contributors.
// Distributed under MIT license. See LICENSE file in the root for more information.

using System.Diagnostics;
using Demo.Engine.Core.Interfaces;
using Demo.Engine.Core.ValueObjects;
using Microsoft.Extensions.Logging;

namespace Demo.Engine.Core.Services;

internal sealed class FpsTimer(
    ILogger<FpsTimer> logger)
    : IFpsTimer
{
    internal sealed class SurfaceFpsCounter(
        ILogger logger,
        RenderingSurfaceId surfaceId)
        : IFpsTimer.IFpsInternalTimer
    {
        private readonly ILogger _logger = logger;
        private readonly RenderingSurfaceId _surfaceId = surfaceId;

        private float _averageMs { get; set; } = 0.0f;
        private ulong _fpsCounter { get; set; } = 1;
        private long _start;
        private long _seconds = Stopwatch.GetTimestamp();

        public void Start()
            => _start = Stopwatch.GetTimestamp();

        public void Stop()
        {
            var dt = Stopwatch.GetElapsedTime(_start);

            _averageMs += (dt.Milliseconds - _averageMs) / _fpsCounter;
            ++_fpsCounter;

            if (Stopwatch.GetElapsedTime(_seconds).TotalSeconds >= 1)
            {
                _logger.LogAverageSurfaceFps(
                    _surfaceId,
                    _averageMs,
                    _fpsCounter);

                _averageMs = 0.0f;
                _fpsCounter = 1;
                _seconds = Stopwatch.GetTimestamp();
            }
        }
    }

    private readonly ILogger<FpsTimer> _logger = logger;
    private readonly Dictionary<RenderingSurfaceId, SurfaceFpsCounter> _surfaceFpsCounters = [];

    public void StartRenderingTimer(
        RenderingSurfaceId surfaceId)
    {
        if (!_surfaceFpsCounters.TryGetValue(
            surfaceId,
            out var fpsCounter))
        {
            fpsCounter = new SurfaceFpsCounter(
                _logger,
                surfaceId);

            _surfaceFpsCounters.Add(
                surfaceId,
                fpsCounter);
        }

        fpsCounter.Start();
    }

    public FpsTimerScope StartRenderingTimerScope(
        RenderingSurfaceId surfaceId)
    {
        if (!_surfaceFpsCounters.TryGetValue(
            surfaceId,
            out var fpsCounter))
        {
            fpsCounter = new SurfaceFpsCounter(
                _logger,
                surfaceId);

            _surfaceFpsCounters.Add(
                surfaceId,
                fpsCounter);
        }

        return new FpsTimerScope(
            fpsCounter);
    }

    public void StopRenderingTimer(
        RenderingSurfaceId surfaceId)
    {
        if (_surfaceFpsCounters.TryGetValue(
            surfaceId,
            out var fpsCounter))
        {
            fpsCounter.Stop();
        }
    }

    private float _averageMs { get; set; } = 0.0f;
    private ulong _upsCounter { get; set; } = 1;
    private long _start;
    private long _seconds = Stopwatch.GetTimestamp();

    public void StartUpdateTimer()
        => _start = Stopwatch.GetTimestamp();

    public void StopUpdateTimer()
    {
        var dt = Stopwatch.GetElapsedTime(_start);

        _averageMs += (dt.Milliseconds - _averageMs) / _upsCounter;
        ++_upsCounter;

        if (Stopwatch.GetElapsedTime(_seconds).TotalSeconds >= 1)
        {
            _logger.LogAverageUps(
                _averageMs,
                _upsCounter);

            _averageMs = 0.0f;
            _upsCounter = 1;
            _seconds = Stopwatch.GetTimestamp();
        }
    }
}

1	// Copyright © Michał Dembski and contributors.
2	// Distributed under MIT license. See LICENSE file in the root for more information.
3
4	using System.Diagnostics;
5	using Demo.Engine.Core.Interfaces;
6	using Demo.Engine.Core.ValueObjects;
7	using Microsoft.Extensions.Logging;
8
9	namespace Demo.Engine.Core.Services;
10
11	internal sealed class FpsTimer(	1✔
12	ILogger<FpsTimer> logger)	1✔
13	: IFpsTimer
14	{
15	internal sealed class SurfaceFpsCounter(	2✔
16	ILogger logger,	2✔
17	RenderingSurfaceId surfaceId)	2✔
18	: IFpsTimer.IFpsInternalTimer
19	{
20	private readonly ILogger _logger = logger;	2✔
21	private readonly RenderingSurfaceId _surfaceId = surfaceId;	2✔
22
23	private float _averageMs { get; set; } = 0.0f;	2✔
24	private ulong _fpsCounter { get; set; } = 1;	2✔
25	private long _start;
26	private long _seconds = Stopwatch.GetTimestamp();	2✔
27
28	public void Start()
29	=> _start = Stopwatch.GetTimestamp();	2✔
30
31	public void Stop()
32	{
33	var dt = Stopwatch.GetElapsedTime(_start);	2✔
34
35	_averageMs += (dt.Milliseconds - _averageMs) / _fpsCounter;	2✔
36	++_fpsCounter;	2✔
37
38	if (Stopwatch.GetElapsedTime(_seconds).TotalSeconds >= 1)
39	{
40	_logger.LogAverageSurfaceFps(	×
41	_surfaceId,	×
42	_averageMs,	×
43	_fpsCounter);	×
44
45	_averageMs = 0.0f;	×
46	_fpsCounter = 1;	×
47	_seconds = Stopwatch.GetTimestamp();	×
48	}
49	}	2✔
50	}
51
52	private readonly ILogger<FpsTimer> _logger = logger;	1✔
53	private readonly Dictionary<RenderingSurfaceId, SurfaceFpsCounter> _surfaceFpsCounters = [];	1✔
54
55	public void StartRenderingTimer(
56	RenderingSurfaceId surfaceId)
57	{
58	if (!_surfaceFpsCounters.TryGetValue(
59	surfaceId,
60	out var fpsCounter))
61	{
62	fpsCounter = new SurfaceFpsCounter(
63	_logger,
64	surfaceId);
65
66	_surfaceFpsCounters.Add(
67	surfaceId,
68	fpsCounter);
69	}
70
71	fpsCounter.Start();
72	}
73
74	public FpsTimerScope StartRenderingTimerScope(
75	RenderingSurfaceId surfaceId)
76	{
77	if (!_surfaceFpsCounters.TryGetValue(	1✔
78	surfaceId,	1✔
79	out var fpsCounter))	1✔
80	{
81	fpsCounter = new SurfaceFpsCounter(	1✔
82	_logger,	1✔
83	surfaceId);	1✔
84
85	_surfaceFpsCounters.Add(	1✔
86	surfaceId,	1✔
87	fpsCounter);	1✔
88	}
89
90	return new FpsTimerScope(	1✔
91	fpsCounter);	1✔
92	}
93
94	public void StopRenderingTimer(
95	RenderingSurfaceId surfaceId)
96	{
97	if (_surfaceFpsCounters.TryGetValue(
98	surfaceId,
99	out var fpsCounter))
100	{
101	fpsCounter.Stop();
102	}
103	}
104
105	private float _averageMs { get; set; } = 0.0f;	1✔
106	private ulong _upsCounter { get; set; } = 1;	1✔
107	private long _start;
108	private long _seconds = Stopwatch.GetTimestamp();	1✔
109
110	public void StartUpdateTimer()
111	=> _start = Stopwatch.GetTimestamp();	1✔
112
113	public void StopUpdateTimer()
114	{
115	var dt = Stopwatch.GetElapsedTime(_start);	1✔
116
117	_averageMs += (dt.Milliseconds - _averageMs) / _upsCounter;	1✔
118	++_upsCounter;	1✔
119
120	if (Stopwatch.GetElapsedTime(_seconds).TotalSeconds >= 1)
121	{
122	_logger.LogAverageUps(
123	_averageMs,
124	_upsCounter);
125
126	_averageMs = 0.0f;
127	_upsCounter = 1;
128	_seconds = Stopwatch.GetTimestamp();
129	}
130	}	1✔
131	}

DemoBytom / DemoEngine / 22199895999

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous