Эффективное логирование в Visual Studio: отслеживание действий пользователя

// Пример базового логирования
System.Diagnostics.Trace.WriteLine("Пользователь нажал кнопку 'Сохранить'");
System.Diagnostics.Trace.TraceInformation("Загрузка формы завершена");
System.Diagnostics.Trace.TraceWarning("Предупреждение: медленное выполнение операции");
System.Diagnostics.Trace.TraceError("Ошибка при обработке запроса");

// Программная настройка логирования в файл
TextWriterTraceListener textListener = new TextWriterTraceListener("useractions.log");
Trace.Listeners.Add(textListener);
Trace.AutoFlush = true; // Автоматическая запись в файл без буферизации

<configuration>
<system.diagnostics>
<trace autoflush="true">
<listeners>
<add name="logFile" type="System.Diagnostics.TextWriterTraceListener" 
initializeData="application_user_actions.log" />
</listeners>
</trace>
</system.diagnostics>
</configuration>

// Определение источника логов
TraceSource userActionSource = new TraceSource("UserActions", SourceLevels.All);

// Логирование по категориям
userActionSource.TraceEvent(TraceEventType.Information, 1001, "Пользователь открыл форму редактирования");
userActionSource.TraceEvent(TraceEventType.Warning, 2001, "Долгое ожидание ответа от сервера");
userActionSource.TraceEvent(TraceEventType.Critical, 5001, "Критическая ошибка при обработке данных");

// Закрытие источника в конце работы
userActionSource.Close();

// Создание активности для отслеживания пользовательского действия
using (var activity = new System.Diagnostics.Activity("UserLogin").Start())
{
activity.AddTag("UserID", userId);
activity.AddTag("Browser", userAgent);

// Логика входа пользователя

// Если возникает ошибка
if (error)
{
activity.AddTag("Error", errorMessage);
}
}

// Настройка Serilog
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.WithProperty("Application", "MyApp")
.Enrich.WithMachineName()
.WriteTo.Console()
.WriteTo.File("logs/useractions.json", rollingInterval: RollingInterval.Day, 
formatter: new JsonFormatter())
.CreateLogger();

// Логирование действий пользователя со структурированными данными
Log.Information("Пользователь {UserId} выполнил {Action} в модуле {Module}",
userId, "EditProfile", "AccountManagement");

// Логирование с вложенными объектами
Log.Information("Изменение настроек {@Settings}", new { ThemeColor = "Dark", NotificationsEnabled = true });

// Пример конфигурации NLog для логирования действий пользователя
var config = new LoggingConfiguration();

// Настройка целей для записи логов
var fileTarget = new FileTarget("file")
{
FileName = "${basedir}/logs/${shortdate}_user_actions.log",
Layout = "${longdate}|${level}|${message}|${exception:format=toString}"
};

var databaseTarget = new DatabaseTarget("database")
{
ConnectionString = "Data Source=.;Initial Catalog=AppLogs;Integrated Security=True;",
CommandText = "INSERT INTO UserActions (TimeStamp, Level, Message, UserId, Action) " +
"VALUES (@TimeStamp, @Level, @Message, @UserId, @Action)"
};
databaseTarget.Parameters.Add(new DatabaseParameterInfo("@TimeStamp", "${longdate}"));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("@Level", "${level}"));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("@Message", "${message}"));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("@UserId", "${event-properties:item=UserId}"));
databaseTarget.Parameters.Add(new DatabaseParameterInfo("@Action", "${event-properties:item=Action}"));

// Добавление целей в конфигурацию
config.AddTarget(fileTarget);
config.AddTarget(databaseTarget);

// Настройка правил
config.AddRuleForAllLevels(fileTarget);
config.AddRule(LogLevel.Info, LogLevel.Fatal, databaseTarget);

// Применение конфигурации
LogManager.Configuration = config;

// Использование в коде
var logger = LogManager.GetCurrentClassLogger();
var logEvent = new LogEventInfo(LogLevel.Info, "", "Пользователь открыл форму заказа");
logEvent.Properties["UserId"] = currentUser.Id;
logEvent.Properties["Action"] = "OpenOrderForm";
logger.Log(logEvent);

// Настройка log4net
var repository = LogManager.GetRepository(Assembly.GetEntryAssembly());
XmlConfigurator.Configure(repository, new FileInfo("log4net.config"));

// Логирование действий пользователя
ILog logger = LogManager.GetLogger(typeof(UserActionsLogger));

// Создание контекста для логирования дополнительной информации
ThreadContext.Properties["UserId"] = currentUser.Id;
ThreadContext.Properties["SessionId"] = HttpContext.Current?.Session.SessionID;

logger.Info($"Пользователь выполнил поиск по критерию: {searchTerm}");

// При необходимости очистка контекста
ThreadContext.Properties.Remove("UserId");
ThreadContext.Properties.Remove("SessionId");

// Настройка в Program.cs или Startup.cs
public void ConfigureServices(IServiceCollection services)
{
services.AddLogging(builder =>
{
builder.AddConsole();
builder.AddDebug();
builder.AddEventLog();
builder.AddFile("logs/useractions-{Date}.log");

// Настройка минимального уровня логирования
builder.SetMinimumLevel(LogLevel.Information);
});
}

// Использование в коде через DI
public class UserController : Controller
{
private readonly ILogger<UserController> _logger;

public UserController(ILogger<UserController> logger)
{
_logger = logger;
}

public IActionResult Profile()
{
_logger.LogInformation("Пользователь {UserId} просмотрел свой профиль", User.Identity.Name);
// ...
}
}

public class UserActionLoggingMiddleware
{
private readonly RequestDelegate _next;
private readonly ILogger<UserActionLoggingMiddleware> _logger;

public UserActionLoggingMiddleware(RequestDelegate next, ILogger<UserActionLoggingMiddleware> logger)
{
_next = next;
_logger = logger;
}

public async Task InvokeAsync(HttpContext context)
{
// Фиксация времени начала запроса
var stopwatch = Stopwatch.StartNew();

// Создание ID для корреляции логов одного запроса
var correlationId = Guid.NewGuid().ToString();
context.Items["CorrelationId"] = correlationId;

// Логирование начала запроса
_logger.LogInformation("Request {Method} {Path} started. CorrelationId: {CorrelationId}, User: {User}",
context.Request.Method,
context.Request.Path,
correlationId,
context.User?.Identity?.Name ?? "Anonymous");

try
{
// Выполнение следующего middleware в цепочке
await _next(context);
}
catch (Exception ex)
{
// Логирование исключений
_logger.LogError(ex, "Request failed. CorrelationId: {CorrelationId}", correlationId);
throw;
}
finally
{
stopwatch.Stop();

// Логирование завершения запроса
_logger.LogInformation(
"Request {Method} {Path} completed in {ElapsedMs}ms with status {StatusCode}. CorrelationId: {CorrelationId}",
context.Request.Method,
context.Request.Path,
stopwatch.ElapsedMilliseconds,
context.Response.StatusCode,
correlationId);
}
}
}

// Регистрация middleware в Startup.cs
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
// Другие middleware...

app.UseMiddleware<UserActionLoggingMiddleware>();

app.UseRouting();
// ...
}

[TypeFilter(typeof(UserActionLogAttribute))]
public class ProductController : Controller
{
private readonly ILogger<ProductController> _logger;

public ProductController(ILogger<ProductController> logger)
{
_logger = logger;
}

[LogUserAction(Description = "Просмотр списка продуктов")]
public IActionResult Index()
{
_logger.LogInformation("Пользователь {User} просматривает каталог продуктов", User.Identity.Name);
// Логика метода...
return View();
}

[LogUserAction(Description = "Детальный просмотр продукта")]
public IActionResult Details(int id)
{
_logger.LogInformation("Пользователь {User} просматривает продукт {ProductId}", 
User.Identity.Name, id);
// Логика метода...
return View();
}
}

// Атрибут для логирования действий
public class LogUserActionAttribute : ActionFilterAttribute
{
public string Description { get; set; }
private readonly ILogger<LogUserActionAttribute> _logger;

public LogUserActionAttribute(ILogger<LogUserActionAttribute> logger)
{
_logger = logger;
}

public override void OnActionExecuting(ActionExecutingContext context)
{
var actionName = context.ActionDescriptor.DisplayName;
var user = context.HttpContext.User.Identity.Name ?? "Anonymous";
var correlationId = context.HttpContext.Items["CorrelationId"] as string;

_logger.LogInformation("Action {Action} executing. Description: {Description}. User: {User}. CorrelationId: {CorrelationId}",
actionName, Description, user, correlationId);

base.OnActionExecuting(context);
}

public override void OnActionExecuted(ActionExecutedContext context)
{
base.OnActionExecuted(context);

var actionName = context.ActionDescriptor.DisplayName;
var correlationId = context.HttpContext.Items["CorrelationId"] as string;

if (context.Exception != null)
{
_logger.LogError(context.Exception, 
"Action {Action} failed. CorrelationId: {CorrelationId}", 
actionName, correlationId);
}
else
{
_logger.LogInformation("Action {Action} executed successfully. CorrelationId: {CorrelationId}", 
actionName, correlationId);
}
}
}

// Декоратор для команд с логированием
public class LoggingCommandDecorator<T> : ICommand
{
private readonly ICommand _innerCommand;
private readonly ILogger _logger;
private readonly string _commandDescription;

public LoggingCommandDecorator(ICommand innerCommand, ILogger logger, string commandDescription)
{
_innerCommand = innerCommand;
_logger = logger;
_commandDescription = commandDescription;
}

public event EventHandler CanExecuteChanged
{
add { _innerCommand.CanExecuteChanged += value; }
remove { _innerCommand.CanExecuteChanged -= value; }
}

public bool CanExecute(object parameter)
{
return _innerCommand.CanExecute(parameter);
}

public void Execute(object parameter)
{
_logger.LogInformation("Executing command: {CommandDescription}. Parameter: {@Parameter}", 
_commandDescription, parameter);

try
{
_innerCommand.Execute(parameter);
_logger.LogInformation("Command executed successfully: {CommandDescription}", _commandDescription);
}
catch (Exception ex)
{
_logger.LogError(ex, "Command execution failed: {CommandDescription}", _commandDescription);
throw;
}
}
}

// Использование в ViewModel
public class MainViewModel : ViewModelBase
{
private readonly ILogger<MainViewModel> _logger;

public ICommand SaveCommand { get; }
public ICommand DeleteCommand { get; }

public MainViewModel(ILogger<MainViewModel> logger)
{
_logger = logger;

// Создание команд с логированием
var saveCommand = new RelayCommand<Customer>(SaveCustomer);
SaveCommand = new LoggingCommandDecorator<Customer>(saveCommand, _logger, "Save Customer");

var deleteCommand = new RelayCommand<Customer>(DeleteCustomer);
DeleteCommand = new LoggingCommandDecorator<Customer>(deleteCommand, _logger, "Delete Customer");
}

private void SaveCustomer(Customer customer)
{
_logger.LogInformation("Saving customer: {@Customer}", customer);
// Реализация сохранения...
}

private void DeleteCustomer(Customer customer)
{
_logger.LogInformation("Deleting customer: {CustomerId}", customer.Id);
// Реализация удаления...
}
}

// В файле MainWindow.xaml.cs
public partial class MainWindow : Window
{
private readonly ILogger<MainWindow> _logger;

public MainWindow(ILogger<MainWindow> logger)
{
InitializeComponent();
_logger = logger;

// Подписка на события элементов управления
btnSave.Click += (s, e) => _logger.LogInformation("Save button clicked");
txtSearch.TextChanged += (s, e) => _logger.LogDebug("Search text changed: {SearchText}", txtSearch.Text);

// Логирование жизненного цикла окна
Loaded += (s, e) => _logger.LogInformation("Main window loaded");
Closing += (s, e) => _logger.LogInformation("Main window closing");
}
}

public class AppCenterLogger : ILogger
{
private readonly string _categoryName;

public AppCenterLogger(string categoryName)
{
_categoryName = categoryName;
}

public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, 
Func<TState, Exception, string> formatter)
{
if (!IsEnabled(logLevel))
return;

var message = formatter(state, exception);
var properties = new Dictionary<string, string>
{
{ "CategoryName", _categoryName },
{ "EventId", eventId.ToString() }
};

// Добавление свойств из структурированного логирования
if (state is IEnumerable<KeyValuePair<string, object>> stateProperties)
{
foreach (var prop in stateProperties)
{
if (prop.Value != null)
{
properties[prop.Key] = prop.Value.ToString();
}
}
}

// Отправка в App Center
switch (logLevel)
{
case LogLevel.Critical:
case LogLevel.Error:
Analytics.TrackEvent($"Error: {message}", properties);
if (exception != null)
Crashes.TrackError(exception, properties);
break;
case LogLevel.Warning:
Analytics.TrackEvent($"Warning: {message}", properties);
break;
default:
Analytics.TrackEvent(message, properties);
break;
}

// Локальное кэширование для последующей отправки при наличии сети
if (!Connectivity.NetworkAccess == NetworkAccess.Internet)
{
// Сохранение в локальную базу данных для последующей синхронизации
SaveToLocalCache(logLevel, message, properties, exception);
}
}

public bool IsEnabled(LogLevel logLevel)
{
return logLevel >= LogLevel.Information;
}

public IDisposable BeginScope<TState>(TState state)
{
return new NoopDisposable();
}

private class NoopDisposable : IDisposable
{
public void Dispose() { }
}

private void SaveToLocalCache(LogLevel logLevel, string message, 
Dictionary<string, string> properties, Exception exception)
{
// Реализация сохранения в локальное хранилище...
}
}

// Фильтрация вывода в Output Window
Debug.WriteLine("[USER_ACTION] Пользователь открыл меню настроек");
// Будет видно при фильтрации по [USER_ACTION]

// Язык запросов Kusto (KQL) в Application Insights
requests
| where timestamp > ago(7d)
| where client_Type == "Browser"
| extend actionName = tostring(customDimensions.ActionName)
| extend userId = tostring(customDimensions.UserId)
| summarize count() by actionName, userId
| order by count_ desc
| top 20 by count_

// Построение цепочки действий пользователя в Elasticsearch (запрос на языке DSL)
{
"size": 0,
"query": {
"bool": {
"must": [
{ "match": { "userId": "user123" } },
{ "range": { "@timestamp": { "gte": "now-1h", "lt": "now" } } }
]
}
},
"aggs": {
"actions_over_time": {
"date_histogram": {
"field": "@timestamp",
"calendar_interval": "1m"
},
"aggs": {
"action_types": {
"terms": {
"field": "action.keyword",
"size": 10
}
}
}
}
}
}

// Анализ продолжительности операций в Jaeger (через OpenTracing API)
using (var scope = _tracer.BuildSpan("UserEditProfile").StartActive(finishSpanOnDispose: true))
{
scope.Span.SetTag("user.id", userId);

try
{
// Логика операции...

using (var childScope = _tracer.BuildSpan("SaveProfileImage").StartActive(finishSpanOnDispose: true))
{
// Вложенная операция...
childScope.Span.SetTag("image.size", imageSize);
}
}
catch (Exception ex)
{
scope.Span.SetTag("error", true);
scope.Span.Log(new Dictionary<string, object> { { "error.message", ex.Message } });
throw;
}
}