Map client application's DTO to service-proxy's DataContract
Is it good to map every DTOs into Proxy's DataContract? As my this
  class will grow with more service calls with different DTOs.


Yes, mapping to your own domain improves modularity by decoupling the DTO library from your domain.


  How this class should be architect so that it doesn't violate
  SRP/Design-patterns?



Use either a custom or existing mapping framework to remove the boiler-plate mapping code from your flow. You could create a Mapper class.
Consider using AOP for refactoring boiler-plate try-catch blocks. You could create a LogEntryExitAndErrorAnnotation class.
Your reponse object is not required
Use a using block to dispose the client
Don't use a boolean, when it is always true on success, and hidden when an exception occured.


adapted:

     [LogEntryExitAndErrorAnnotation]
     public void Send()
     {
          var sd = mapper.Map&lt;Proxy.MessageProcessorProxy.SessionDetails&gt;(_sessionDataDTO);               

          // see notes below why to use an adapter
          using (var client = new MessageProcessorClientAdapter(
              new Proxy.MessageProcessorProxy.MessageProcessorClient()))
                  client.LogEventDetails(sd);
     }


Note on (4)

As the OP pointed out: Dispose could hide the root exception.

To avoid this, you can use an adapter. I would use T4 templates to generate these for all my clients.

Suppose your client interface is

public interface IMessageProcessorClient : IDisposable {
    void LogEventDetails(object data); // or typed class
}


You can use the code below to have the best possible exception details. If no error occured during the operation, the error of Dispose is thrown, else an aggregate error is thrown.

public class MessageProcessorClientAdapter : IMessageProcessorClient {
    public IMessageProcessorClient Source {get; private set;}
    public Exception Error {get;private set;}
    public MessageProcessorClientAdapter(IMessageProcessorClient source) {
        this.Source = source; // check for null
    }
    public void LogEventDetails(object data) {
        try {
            this.Source.LogEventDetails(data);
        } catch (Exception error) {
            this.Error = error;
        }
    }
    public void Dispose() {
        try {
            this.Source.Dispose();
        } catch (Exception error) {
            if (this.Error == null) {
                this.Error = error;
            } else {
                this.Error = new AggregateException(this.Error, error);
            }
        } finally {
            if (this.Error != null) {               
                throw this.Error;
            }
        }
    }