Use @SciMLMessage macro and add condition_number verbosity setting

Based on review feedback:

1. Replaced direct logging with @SciMLMessage macro
   - Updated log_blas_info to use @SciMLMessage with proper syntax
   - Structured log messages with appropriate categories and groups
   - Removed direct @info/@warn calls

2. Added condition_number as a separate verbosity setting
   - Added condition_number to LinearNumericalVerbosity struct
   - Condition number computation now controlled by verbosity setting
   - Default is Verbosity.None() to avoid expensive computation

3. Fixed verbosity checks
   - Use verbosity_to_int() for proper verbosity level checking
   - Ensures correct comparison with Verbosity.None()

4. Updated BLISLUFactorization extension
   - Uses @SciMLMessage for success messages
   - Proper verbosity checks before computing operation info
   - Only calls get_blas_operation_info when logging is enabled

5. Updated documentation
   - Added condition_number verbosity setting documentation
   - Clarified that condition number is controlled by verbosity

6. Updated tests
   - Tests now use verbosity parameter for condition number control
   - Verifies condition number is not computed when disabled

These changes ensure efficient logging with proper use of the
SciMLLogging infrastructure and make condition number computation
a controllable option.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: claude

docs/src/basics/common_solver_opts.md

@@ -119,6 +119,7 @@ sol = solve(prob; verbose=verbose)
 - blas_errors: Controls messages for BLAS/LAPACK errors like singular matrices (default: Warn)
 - blas_info: Controls informational messages from BLAS/LAPACK operations (default: None)
 - blas_success: Controls success messages from BLAS/LAPACK operations (default: None)
+- condition_number: Controls computation and logging of matrix condition numbers (default: None)
 
 ### BLAS/LAPACK Return Code Interpretation
 
@@ -141,10 +142,11 @@ LinearSolve.jl now provides detailed interpretation of BLAS/LAPACK return codes
 ```julia
 using LinearSolve
 
-# Enable detailed BLAS error logging
+# Enable detailed BLAS error logging with condition numbers
 verbose = LinearVerbosity(
-    blas_errors = Verbosity.Info(),  # Show detailed error interpretations
-    blas_info = Verbosity.Info()     # Show all BLAS operation details
+    blas_errors = Verbosity.Info(),     # Show detailed error interpretations
+    blas_info = Verbosity.Info(),       # Show all BLAS operation details
+    condition_number = Verbosity.Info() # Compute and log condition numbers
 )
 
 # Solve a potentially singular system
@@ -164,4 +166,4 @@ The enhanced logging also provides:
 - Matrix properties (size, type, element type)
 - Memory usage estimates
 - Detailed context for debugging numerical issues
-- Optional condition number computation (can be enabled via compute_condition parameter)
+- Condition number computation controlled by the condition_number verbosity setting

ext/LinearSolveBLISExt.jl

@@ -13,7 +13,7 @@ using LinearSolve: ArrayInterface, BLISLUFactorization, @get_cacheval, LinearCac
                    interpret_blas_code, log_blas_info, get_blas_operation_info, 
                    check_and_log_lapack_result, LinearVerbosity
 using SciMLBase: ReturnCode
-using SciMLLogging: Verbosity
+using SciMLLogging: Verbosity, @SciMLMessage, verbosity_to_int
 
 const global libblis = blis_jll.blis
 const global liblapack = LAPACK_jll.liblapack
@@ -238,14 +238,15 @@ function SciMLBase.solve!(cache::LinearCache, alg::BLISLUFactorization;
         info_value = res[3]
         if info_value != 0
             # Only get operation info if we need to log
-            if !(verbose.numerical.blas_errors isa Verbosity.None)
-                op_info = get_blas_operation_info(:dgetrf, A, cache.b)
+            if verbosity_to_int(verbose.numerical.blas_errors) > 0
+                op_info = get_blas_operation_info(:dgetrf, A, cache.b, verbose)
                 log_blas_info(:dgetrf, info_value, verbose; extra_context=op_info)
             end
-        elseif !(verbose.numerical.blas_success isa Verbosity.None)
+        elseif verbosity_to_int(verbose.numerical.blas_success) > 0
             # Only get operation info if we need to log success
-            op_info = get_blas_operation_info(:dgetrf, A, cache.b)
-            @info "BLAS LU factorization (dgetrf) completed successfully" op_info
+            op_info = get_blas_operation_info(:dgetrf, A, cache.b, verbose)
+            success_msg = "BLAS LU factorization (dgetrf) completed successfully for $(op_info[:matrix_size]) matrix"
+            @SciMLMessage(success_msg, verbose.numerical.blas_success, :blas_success, :numerical)
         end
 
         if !LinearAlgebra.issuccess(fact[1])
@@ -270,7 +271,7 @@ function SciMLBase.solve!(cache::LinearCache, alg::BLISLUFactorization;
     end
 
     # Log solve operation result if there was an error
-    if info[] != 0 && !(verbose.numerical.blas_errors isa Verbosity.None)
+    if info[] != 0 && verbosity_to_int(verbose.numerical.blas_errors) > 0
         log_blas_info(:dgetrs, info[], verbose)
     end
 

src/blas_logging.jl

@@ -1,6 +1,7 @@
 # BLAS and LAPACK Return Code Interpretation
 
-using SciMLLogging: Verbosity, @match
+using SciMLLogging: Verbosity, @match, @SciMLMessage, verbosity_to_int
+using LinearAlgebra: cond
 
 """
     interpret_blas_code(func::Symbol, info::Integer)
@@ -112,52 +113,30 @@ function log_blas_info(func::Symbol, info::Integer, verbose::LinearVerbosity;
         verbose.numerical.blas_info
     end
 
-    # Format the log message
-    log_msg = format_blas_log_message(func, info, category, message, details, extra_context)
+    # Build structured message components
+    msg_main = "BLAS/LAPACK $func: $message"
+    msg_details = !isempty(details) ? details : nothing
+    msg_info = info
 
-    # Log based on verbosity level
-    log_with_verbosity(verbosity_field, log_msg, category)
-end
-
-function format_blas_log_message(func::Symbol, info::Integer, category::Symbol,
-                                message::String, details::String, 
-                                extra_context::Dict{Symbol,Any})
-    msg_parts = String[]
-    
-    # Main message
-    push!(msg_parts, "BLAS/LAPACK $func: $message")
-    
-    # Add details if present
-    if !isempty(details)
-        push!(msg_parts, "  Details: $details")
-    end
-    
-    # Add return code
-    push!(msg_parts, "  Return code (info): $info")
-    
-    # Add extra context if provided
-    if !isempty(extra_context)
-        for (key, value) in extra_context
-            push!(msg_parts, "  $(key): $value")
+    # Build complete message with all details
+    full_msg = if !isempty(extra_context) || msg_details !== nothing
+        parts = String[msg_main]
+        if msg_details !== nothing
+            push!(parts, "Details: $msg_details")
         end
-    end
-    
-    return join(msg_parts, "\n")
-end
-
-function log_with_verbosity(verbosity::Verbosity.Type, message::String, category::Symbol)
-    @match verbosity begin
-        Verbosity.None() => nothing
-        Verbosity.Info() => @info message
-        Verbosity.Warn() => @warn message
-        Verbosity.Error() => error(message)
-        Verbosity.Level(n) => begin
-            if n >= 1
-                @info message
+        push!(parts, "Return code (info): $msg_info")
+        if !isempty(extra_context)
+            for (key, value) in extra_context
+                push!(parts, "$key: $value")
             end
         end
-        _ => @warn message
+        join(parts, "\n  ")
+    else
+        "$msg_main (info=$msg_info)"
     end
+    
+    # Use proper @SciMLMessage syntax
+    @SciMLMessage(full_msg, verbosity_field, :blas_return_code, :numerical)
 end
 
 """
@@ -190,23 +169,29 @@ end
 
 # Extended information for specific BLAS operations
 """
-    get_blas_operation_info(func::Symbol, A, b=nothing; compute_condition=false)
+    get_blas_operation_info(func::Symbol, A, b, verbose::LinearVerbosity)
 
 Get additional information about a BLAS operation for enhanced logging.
-Set compute_condition=true to include condition number computation (may be expensive).
+Condition number is computed based on the condition_number verbosity setting.
 """
-function get_blas_operation_info(func::Symbol, A, b=nothing; compute_condition=false)
+function get_blas_operation_info(func::Symbol, A, b, verbose::LinearVerbosity)
     info = Dict{Symbol,Any}()
 
     # Matrix properties
     info[:matrix_size] = size(A)
     info[:matrix_type] = typeof(A)
     info[:element_type] = eltype(A)
 
-    # Condition number (only if explicitly requested)
-    if compute_condition && size(A, 1) == size(A, 2)
+    # Condition number (based on verbosity setting)
+    should_compute_cond = verbosity_to_int(verbose.numerical.condition_number) > 0
+    if should_compute_cond && size(A, 1) == size(A, 2)
         try
-            info[:condition_number] = cond(A)
+            cond_num = cond(A)
+            info[:condition_number] = cond_num
+            
+            # Log the condition number if enabled  
+            cond_msg = "Matrix condition number: $(round(cond_num, sigdigits=4)) for $(size(A, 1))×$(size(A, 2)) matrix in $func"
+            @SciMLMessage(cond_msg, verbose.numerical.condition_number, :condition_number, :numerical)
         catch
             # Skip if condition number computation fails
         end

src/verbosity.jl

@@ -13,7 +13,8 @@ const linear_defaults = Dict{Symbol, Verbosity.Type}(
     :blas_errors => Verbosity.Warn(),
     :blas_info => Verbosity.None(),
     :blas_success => Verbosity.None(),
-    :blas_invalid_args => Verbosity.Error()
+    :blas_invalid_args => Verbosity.Error(),
+    :condition_number => Verbosity.None()
 )
 mutable struct LinearErrorControlVerbosity
     default_lu_fallback::Verbosity.Type
@@ -89,6 +90,7 @@ mutable struct LinearNumericalVerbosity
     blas_errors::Verbosity.Type
     blas_info::Verbosity.Type
     blas_success::Verbosity.Type
+    condition_number::Verbosity.Type
 
     function LinearNumericalVerbosity(;
             using_IterativeSolvers = linear_defaults[:using_IterativeSolvers],
@@ -99,10 +101,11 @@ mutable struct LinearNumericalVerbosity
             pardiso_verbosity = linear_defaults[:pardiso_verbosity],
             blas_errors = linear_defaults[:blas_errors],
             blas_info = linear_defaults[:blas_info],
-            blas_success = linear_defaults[:blas_success])
+            blas_success = linear_defaults[:blas_success],
+            condition_number = linear_defaults[:condition_number])
         new(using_IterativeSolvers, IterativeSolvers_iterations,
             KrylovKit_verbosity, KrylovJL_verbosity, HYPRE_verbosity, pardiso_verbosity,
-            blas_errors, blas_info, blas_success)
+            blas_errors, blas_info, blas_success, condition_number)
     end
 
     function LinearNumericalVerbosity(verbose::Verbosity.Type)

test/test_blas_logging.jl

@@ -36,15 +36,19 @@ using SciMLLogging: Verbosity
         # Test getting operation info without condition number
         A = rand(10, 10)
         b = rand(10)
-        info = LinearSolve.get_blas_operation_info(:dgetrf, A, b)
+        
+        # Test with condition_number disabled (default)
+        verbose_no_cond = LinearVerbosity(condition_number = Verbosity.None())
+        info = LinearSolve.get_blas_operation_info(:dgetrf, A, b, verbose_no_cond)
 
         @test info[:matrix_size] == (10, 10)
         @test info[:element_type] == Float64
         @test !haskey(info, :condition_number)  # Should not compute by default
         @test info[:memory_usage_MB] >= 0  # Memory can be 0 for very small matrices
 
-        # Test with condition number computation enabled
-        info_with_cond = LinearSolve.get_blas_operation_info(:dgetrf, A, b; compute_condition=true)
+        # Test with condition number computation enabled via verbosity
+        verbose_with_cond = LinearVerbosity(condition_number = Verbosity.Info())
+        info_with_cond = LinearSolve.get_blas_operation_info(:dgetrf, A, b, verbose_with_cond)
         @test haskey(info_with_cond, :condition_number)
     end