Custom Error type from Expected with further matching and deconstructed logging

[earnest]

Hi all,

I created something like this with usage

public record FileNotFoundError(string FileName, string Message, Option<Error> Inner) : Expected(Message, 1, Inner);

Either<Error, Unit> result = Try(() => LoadFileUnsafe).ToEither(err => (Error) new FileNotFoundError(fileName, "File not found", err))
 
result.MapLeft(err => 
{
    // some variations of structured logging deconstruction
    if (err is FileNotFoundError fileError)
    {
        logger.LogError("File error: {@Error}", fileError);
    }
    if (err is SomeOtherError otherError)
    {
        logger.LogError(otherError, "Other error: {@Error}", otherError);
    }
})

With logging, the inner details, stack trace etc are missing. What would be the correct way to use it? What am I missing, please?

Also, for certain Exceptions in the Try, there is a recursive issue where Serilog will keep on nesting until the not support method exception happens (probably I can apply max depth policy). Example of such exception would be ReaderException for some faulty csv file with the CsvHelper library.

[aloslider]

I think everything works, just fix Try constructor

using LanguageExt.Common;
using LanguageExt;
using static LanguageExt.Prelude;
using Microsoft.Extensions.Logging;

var logger = LoggerFactory.Create(b =>
{
    b.AddConsole();
})
.CreateLogger("test");
string fileName = "some.txt";
var result =
    Try(LoadFileUnsafe)
    .ToEither(ex => 
        new FileNotFoundError(fileName, "File not found", Error.New(ex)))
    .MapLeft(err =>
    {
        if (err is FileNotFoundError fileError)
        {
            logger.LogError("File error: {@Error}", fileError);
        }

        return unit;
    });


static Unit LoadFileUnsafe() => throw new Exception("Inner ex");
public record FileNotFoundError(string FileName, string Message, Option<Error> Inner) : Expected(Message, 1, Inner);

Output:

fail: test[0]
      File error: FileNotFoundError { Code = 1, Message = File not found, Inner = Some(Inner ex), IsExceptional = False, IsExpected = True, IsEmpty = False, Count = 1, Exception = None, FileName = some.txt }

[aloslider]

I suggest you to switch from Try to Eff/Aff monads due to their more powerful features, especially when working with Error types. You can learn it here and here. Also, there are well written wiki articles and closed issues labeled as examples/documentation that you can read as well.

[earnest]

@aloslider thanks, will do, especially useful for the upcoming v5, but have to plan for this migration.

@louthy, @aloslider, is this a bug or a not fully supported feature (Try that is or Error creation)? Or am I misusing it?

[aloslider]

For v5, it's better to visit Paul's site where he talks about new functionality in "Higher Kinds in C# with language-ext" series. All references above are about v4, but mostly will be applicable to v5 as well (at least the idea is still the same).

I'm not sure I understood you question, what exact bug do you experience and what do you mean by "not fully supported feature"?

[earnest]

When converting the error to exception, the stack trace is missing

[aloslider]

The stack trace is inside FileNotFoundError's Inner property (fileError.Inner.Exception.StackTrace), which are all Options, so Serilog apparently can't deserialize it so deep. I can't help with Serilog, but at least you can dig through these options and get it:

.MapLeft(err =>
{
    if (err is FileNotFoundError fileError)
    {
        var fullErrorInfo =
            from innerExn in fileError.Inner
            from exn      in innerExn.Exception
            select exn;
        logger.LogError("Stack trace: {@Error}", fullErrorInfo);
        logger.LogError("File error: {@Error}", fileError); // No strack trace as fileError.Inner is Option
    }

    return 1;
});