Nested JObjects getting serialized as empty arrays

You wrote that

I should clarify that I'm on v6.0.8 of Newtonsoft for reasons outside my control, and that the thirdparty assembly that contains the POCO has an unknown version of Newtonsoft ILMerged in it.

This explains your problem. The JobOutput contains an object with full name Newtonsoft.Json.Linq.JObject from a completely different Json.NET DLL than the one you are using. When your version of Json.NET tests to see whether the object being serialized is a JToken, it checks objectType.IsSubclassOf(typeof(JToken)) -- which will fail since the ILMerged type is not, in fact, a subclass of your version's type, despite having the same name.

As a workaround, you will need to create custom JsonConverter logic that uses the ToString() methods of the foreign JToken objects to generate output JSON, then writes that JSON to the JSON stream you are generating. The following should do the job:

public class ForeignJsonNetContainerConverter : ForeignJsonNetBaseConverter
{
    static readonly string [] Names = new []
    {
        "Newtonsoft.Json.Linq.JObject",
        "Newtonsoft.Json.Linq.JArray",
        "Newtonsoft.Json.Linq.JConstructor",
        "Newtonsoft.Json.Linq.JRaw",
    };

    protected override IReadOnlyCollection<string> TypeNames { get { return Names; } }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var json = value.ToString();
        // Fix indentation
        using (var stringReader = new StringReader(json))
        using (var jsonReader = new JsonTextReader(stringReader))
        {
            writer.WriteToken(jsonReader);
        }
    }
}

public class ForeignJsonNetValueConverter : ForeignJsonNetBaseConverter
{
    static readonly string [] Names = new []
    {
        "Newtonsoft.Json.Linq.JValue",
    };

    protected override IReadOnlyCollection<string> TypeNames { get { return Names; } }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var underlyingValue = ((dynamic)value).Value;
        if (underlyingValue == null)
        {
            writer.WriteNull();
        }
        else
        {
            // JValue.ToString() will be wrong for DateTime objects, we need to serialize them instead.
            serializer.Serialize(writer, underlyingValue);
        }
    }
}

public abstract class ForeignJsonNetBaseConverter : JsonConverter
{
    protected abstract IReadOnlyCollection<string> TypeNames { get; }

    public override bool CanConvert(Type objectType)
    {
        if (objectType.IsPrimitive)
            return false;
        // Do not use the converter for Native JToken types, only non-native types with the same name(s).
        if (objectType == typeof(JToken) || objectType.IsSubclassOf(typeof(JToken)))
            return false;
        var fullname = objectType.FullName;
        if (TypeNames.Contains(fullname))
            return true;
        return false;
    }

    public override bool CanRead { get { return false; } }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

And then use them in settings as follows:

var settings = new JsonSerializerSettings
{
    Converters = 
    {
        new ForeignJsonNetContainerConverter(), new ForeignJsonNetValueConverter()
    },
};

var json = JsonConvert.SerializeObject(summary, Formatting.Indented, settings);

Notes:

• The converters work by assuming that types whose FullName matches a Json.NET type's name are, in fact, Json.NET types from a different version.

• JValue.ToString() returns localized values for DateTime objects (see here for details), so I created a separate converter for JValue.

• I also fixed the indentation to match.

Mockup fiddle here.