⌨️ Dev Notebook

-- Top 20 queries by total CPU time
SELECT TOP 20
    SUBSTRING(qt.text, (qs.statement_start_offset/2)+1,
        ((CASE qs.statement_end_offset
            WHEN -1 THEN DATALENGTH(qt.text)
            ELSE qs.statement_end_offset END
        - qs.statement_start_offset)/2)+1)           AS query_text,
    qs.execution_count,
    qs.total_worker_time / 1000                     AS total_cpu_ms,
    qs.total_worker_time / qs.execution_count / 1000  AS avg_cpu_ms,
    qs.total_elapsed_time / 1000                    AS total_elapsed_ms,
    qs.total_logical_reads,
    qp.query_plan
FROM   sys.dm_exec_query_stats qs
CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle)  qt
CROSS APPLY sys.dm_exec_query_plan(qs.plan_handle) qp
ORDER BY qs.total_worker_time DESC;

SELECT
    OBJECT_NAME(i.object_id)          AS table_name,
    i.name                            AS index_name,
    s.avg_fragmentation_in_percent,
    s.page_count,
    CASE
        WHEN s.avg_fragmentation_in_percent > 30 THEN 'REBUILD'
        WHEN s.avg_fragmentation_in_percent > 10 THEN 'REORGANIZE'
        ELSE 'OK'
    END                               AS recommended_action
FROM   sys.dm_db_index_physical_stats(
           DB_ID(), NULL, NULL, NULL, 'LIMITED') s
JOIN   sys.indexes i
       ON s.object_id = i.object_id AND s.index_id = i.index_id
WHERE  s.page_count > 100
  AND  i.name IS NOT NULL
ORDER BY s.avg_fragmentation_in_percent DESC;

public interface IOrderRepository
{
    Task<IEnumerable<Order>> GetPendingOrdersAsync(CancellationToken ct);
    Task<Order?> GetByIdAsync(int orderId, CancellationToken ct);
}

public class OrderRepository(IConfiguration cfg) : IOrderRepository
{
    private readonly string _conn = cfg.GetConnectionString("WmsDb")!;

    public async Task<IEnumerable<Order>> GetPendingOrdersAsync(CancellationToken ct)
    {
        await using var db = new SqlConnection(_conn);
        return await db.QueryAsync<Order>(new CommandDefinition(
            """
            SELECT OrderId, CustomerId, Status, CreatedAt
            FROM   dbo.Orders
            WHERE  Status = 'PENDING'
            ORDER BY CreatedAt ASC
            """, cancellationToken: ct));
    }

    public async Task<Order?> GetByIdAsync(int orderId, CancellationToken ct)
    {
        await using var db = new SqlConnection(_conn);
        return await db.QueryFirstOrDefaultAsync<Order>(new CommandDefinition(
            "SELECT * FROM dbo.Orders WHERE OrderId = @OrderId",
            new { OrderId = orderId }, cancellationToken: ct));
    }
}

public class GlobalExceptionMiddleware(RequestDelegate next, ILogger<GlobalExceptionMiddleware> logger)
{
    public async Task InvokeAsync(HttpContext ctx)
    {
        try
        {
            await next(ctx);
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "Unhandled exception on {Method} {Path}",
                ctx.Request.Method, ctx.Request.Path);

            ctx.Response.StatusCode  = StatusCodes.Status500InternalServerError;
            ctx.Response.ContentType = "application/json";

            await ctx.Response.WriteAsJsonAsync(new {
                status  = 500,
                title   = "An unexpected error occurred",
                traceId = Activity.Current?.Id ?? ctx.TraceIdentifier
            });
        }
    }
}

// Register in Program.cs — must come first
app.UseMiddleware<GlobalExceptionMiddleware>();

WITH DeadlockData AS (
    SELECT
        xdr.value('(//deadlock/process-list/process/@lastbatchstarted)[1]', 'datetime2')
            AS deadlock_time,
        xdr.value('(//deadlock/process-list/process/@hostname)[1]', 'nvarchar(256)')
            AS hostname,
        xdr.query('.')  AS deadlock_xml
    FROM (
        SELECT CAST(target_data AS xml) AS target_data
        FROM   sys.dm_xe_session_targets  t
        JOIN   sys.dm_xe_sessions         s ON t.event_session_address = s.address
        WHERE  s.name = 'system_health'
          AND  t.target_name = 'ring_buffer'
    ) AS src
    CROSS APPLY target_data.nodes('//RingBufferTarget/event[@name="xml_deadlock_report"]') AS n(xdr)
)
SELECT * FROM DeadlockData
ORDER BY deadlock_time DESC;

public abstract class PluginBase : IPlugin
{
    public void Execute(IServiceProvider serviceProvider)
    {
        var context = (IPluginExecutionContext)
            serviceProvider.GetService(typeof(IPluginExecutionContext));
        var factory  = (IOrganizationServiceFactory)
            serviceProvider.GetService(typeof(IOrganizationServiceFactory));
        var service  = factory.CreateOrganizationService(context.UserId);
        var tracer   = (ITracingService)
            serviceProvider.GetService(typeof(ITracingService));
        try
        {
            ExecutePlugin(context, service, tracer);
        }
        catch (InvalidPluginExecutionException) { throw; }
        catch (Exception ex)
        {
            tracer.Trace($"Plugin error: {ex.Message}");
            throw new InvalidPluginExecutionException($"Unexpected: {ex.Message}", ex);
        }
    }

    protected abstract void ExecutePlugin(
        IPluginExecutionContext context,
        IOrganizationService    service,
        ITracingService         tracer);
}

# Undo last commit but keep changes staged
git reset --soft HEAD~1

# Undo last commit AND unstage (still keep files)
git reset --mixed HEAD~1

# Completely discard last commit (DESTRUCTIVE)
git reset --hard HEAD~1

# Stash with a descriptive label
git stash push -m "WIP: order processor refactor"

# Cherry-pick a single commit from another branch
git cherry-pick abc1234

# Binary search for the commit that introduced a bug
git bisect start
git bisect bad          # current is broken
git bisect good v2.1.0  # last known good tag

# Rewrite last 3 commit messages interactively
git rebase -i HEAD~3