You have the annotation in the wrong place - it needs to be on the class, not the field. i.e:

@JsonInclude(Include.NON_NULL) //or Include.NON_EMPTY, if that fits your use case 
public static class Request {
  // ...
}

As noted in comments, in versions below 2.x the syntax for this annotation is:

@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL) // or JsonSerialize.Inclusion.NON_EMPTY

The other option is to configure the ObjectMapper directly, simply by calling mapper.setSerializationInclusion(Include.NON_NULL);

(for the record, I think the popularity of this answer is an indication that this annotation should be applicable on a field-by-field basis, @fasterxml)

Try this approach in your real circumstances:

var cust7 = new
{
   value = ""
};

if( string.IsNullOrWhiteSpace( cust7.value ) ) cust7 = null;

var tudhjs = new
{
   fields = new
   {
      sum = "st",
      // . . .
      cust = new
      {
         id = "23"
      },
      cust7
   }
};

One thing you can do is customize the serialization options by modifying the type info resolver, and setting ShouldSerialize to true for string properties with Length > 0:

var serializerOptions = new JsonSerializerOptions
{
    TypeInfoResolver = new DefaultJsonTypeInfoResolver
    {
        Modifiers =
        {
            info =>
            {
                foreach (var jsonPropertyInfo in info.Properties)
                {
                    if (jsonPropertyInfo.PropertyType == typeof(string))
                    {

                        jsonPropertyInfo.ShouldSerialize = 
                            (_, str) => str is string { Length: > 0 };
                    }
                }
            }
        }
    }
};

var serialized = JsonSerializer.Serialize(new MyClass(), serializerOptions);
Console.WriteLine(serialized); // prints "{"IntProp":0}"

See Customize a JSON contract and Example: Conditional Serialization for more info.

You can customize the JSON contract used by the DefaultJsonTypeInfoResolver or derived type.

Below code changes each property of type string to only serialize when not null and not empty.

This contract customization via property type inspection only occurs once per model type. It is the Func applied to ShouldSerialize that runs for each string property value.

builder.Services
    .AddControllers()
    .AddJsonOptions(o => o.JsonSerializerOptions.TypeInfoResolver = new DefaultJsonTypeInfoResolver()    
    {
        Modifiers =
        { 
            jsonTypeInfo => 
            {
                foreach (var propertyInfo in jsonTypeInfo.Properties.Where(o => o.PropertyType == typeof(string)))
                {
                    propertyInfo.ShouldSerialize = (parent, property) => !string.IsNullOrEmpty(property as string);
                }
            }
        }
    });

Just decorating the properties [JsonProperty(NullValueHandling = NullValueHandling.Ignore)] ONLY should do what you want. Unless the property is getting set to an empty string.

Just wondering, why do you need the DataMemeber attribute?

Here is a link to a working dotnetfiddle

using System;
using Newtonsoft.Json;
using System.ComponentModel;

public class Program
{

    public static void Main()
    {
        var user = new User();

        user.UserID = "1234";
        user.ssn = "";

        var settings = new JsonSerializerSettings();

        settings.NullValueHandling = NullValueHandling.Ignore;
        settings.DefaultValueHandling = DefaultValueHandling.Ignore;


        Console.WriteLine(JsonConvert.SerializeObject(user, settings));
    }
}

public class User
{
    [DefaultValue("")]
    public string UserID { get; set; }

    [DefaultValue("")]
    public string ssn { get; set; }

    [DefaultValue("")]
    public string empID { get; set; }

    [DefaultValue("")]
    public string schemaAgencyName { get; set; }

    [DefaultValue("")]
    public string givenName { get; set; }

    [DefaultValue("")]
    public string familyName { get; set; }

    [DefaultValue("")]
    public string password { get; set; }
}

I have resolved this problem. I have removed the null values during serialization.

string JSONstring = JsonConvert.SerializeObject(dt, new 
JsonSerializerSettings()
{
            NullValueHandling = NullValueHandling.Ignore,
});

And after that empty string values are removed through the following code

var temp = JArray.Parse(JSONstring);
temp.Descendants()
    .OfType<JProperty>()
    .Where(attr => attr.Value.ToString() == "")
    .ToList() // you should call ToList because you're about to changing the result, which is not possible if it is IEnumerable
    .ForEach(attr => attr.Remove()); // removing unwanted attributes

JSONstring = temp.ToString();

To ignore empty string use default value handling option and set property default value to empty string

[DefaultValue("")]
public string key { get; set; }

And in set JsonSerializerSettings as below

new JsonSerializerSettings 
          { DefaultValueHandling = DefaultValueHandling.Ignore }