diff --git a/.nuget/NuGet.exe b/.nuget/NuGet.exe
index 9f8781d..6bb79fe 100644
Binary files a/.nuget/NuGet.exe and b/.nuget/NuGet.exe differ
diff --git a/README.md b/README.md
index c568d07..5c3c642 100644
--- a/README.md
+++ b/README.md
@@ -33,6 +33,7 @@ service/environment.
 - `NotToBeDisplayedDomainList`(optional) - It will be used when logging host name by excluding these strings in service name attribute
 	e.g. domain: ".xyz.com", host: "abc.xyz.com" will be logged as "abc" only    
 - `ExcludedPathList`(optional) - Path list that is not needed for tracing. Each item must start with "/".
+- `Create128BitTraceId` - Create new traces using 128 bit (32 hex character) traceId
 
 
 ```csharp
@@ -166,3 +167,5 @@ ZipkinTracer is (c) Medidata Solutions Worldwide and owned by its major contribu
 * [Kenya Matsumoto](https://github.com/kenyamat)
 * [Brent Villanueva](https://github.com/bvillanueva-mdsol)
 * [Laszlo Schreck](https://github.com/lschreck-mdsol)
+* [Jordi Carres](https://github.com/jcarres-mdsol)
+* [Herry Kurniawan](https://github.com/hkurniawan-mdsol)
diff --git a/src/Medidata.ZipkinTracer.Core/App_Packages/LibLog.4.2/LibLog.cs b/src/Medidata.ZipkinTracer.Core/App_Packages/LibLog.4.2/LibLog.cs
index 45e6da7..22f356c 100644
--- a/src/Medidata.ZipkinTracer.Core/App_Packages/LibLog.4.2/LibLog.cs
+++ b/src/Medidata.ZipkinTracer.Core/App_Packages/LibLog.4.2/LibLog.cs
@@ -422,11 +422,6 @@ interface ILogProvider
     static class LogProvider
     {
 #if !LIBLOG_PROVIDERS_ONLY
-        /// <summary>
-        /// The disable logging environment variable. If the environment variable is set to 'true', then logging
-        /// will be disabled.
-        /// </summary>
-        public const string DisableLoggingEnvironmentVariable = "Medidata.ZipkinTracer.Core_LIBLOG_DISABLE";
         private const string NullLogProvider = "Current Log Provider is not set. Call SetCurrentLogProvider " +
                                                "with a non-null value first.";
         private static dynamic s_currentLogProvider;
@@ -517,15 +512,17 @@ static ILog GetCurrentClassLogger()
         /// Gets a logger for the specified type.
         /// </summary>
         /// <param name="type">The type whose name will be used for the logger.</param>
+        /// <param name="fallbackTypeName">If the type is null then this name will be used as the log name instead</param>
         /// <returns>An instance of <see cref="ILog"/></returns>
 #if LIBLOG_PUBLIC
         public
 #else
         internal
 #endif
-        static ILog GetLogger(Type type)
+        static ILog GetLogger(Type type, string fallbackTypeName = "System.Object")
         {
-            return GetLogger(type.FullName);
+            // If the type passed in is null then fallback to the type name specified
+            return GetLogger(type != null ? type.FullName : fallbackTypeName);
         }
 
         /// <summary>
@@ -541,7 +538,7 @@ static ILog GetLogger(Type type)
         static ILog GetLogger(string name)
         {
             ILogProvider logProvider = CurrentLogProvider ?? ResolveLogProvider();
-            return logProvider == null 
+            return logProvider == null
                 ? NoOpLogger.Instance
                 : (ILog)new LoggerExecutionWrapper(logProvider.GetLogger(name), () => IsDisabled);
         }
@@ -693,15 +690,6 @@ public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception
             {
                 return false;
             }
-#if !LIBLOG_PORTABLE
-            var envVar = Environment.GetEnvironmentVariable(LogProvider.DisableLoggingEnvironmentVariable);
-
-            if (envVar != null && envVar.Equals("true", StringComparison.OrdinalIgnoreCase))
-            {
-                return false;
-            }
-#endif
-
             if (messageFunc == null)
             {
                 return _logger(logLevel, null);
@@ -757,7 +745,7 @@ internal abstract class LogProviderBase : ILogProvider
 
         protected LogProviderBase()
         {
-            _lazyOpenNdcMethod 
+            _lazyOpenNdcMethod
                 = new Lazy<OpenNdc>(GetOpenNdcMethod);
             _lazyOpenMdcMethod
                = new Lazy<OpenMdc>(GetOpenMdcMethod);
@@ -871,6 +859,55 @@ internal class NLogLogger
         {
             private readonly dynamic _logger;
 
+            private static Func<string, object, string, Exception, object> _logEventInfoFact;
+
+            private static readonly object _levelTrace;
+            private static readonly object _levelDebug;
+            private static readonly object _levelInfo;
+            private static readonly object _levelWarn;
+            private static readonly object _levelError;
+            private static readonly object _levelFatal;
+
+            static NLogLogger()
+            {
+                try
+                {
+                    var logEventLevelType = Type.GetType("NLog.LogLevel, NLog");
+                    if (logEventLevelType == null)
+                    {
+                        throw new InvalidOperationException("Type NLog.LogLevel was not found.");
+                    }
+
+                    var levelFields = logEventLevelType.GetFieldsPortable().ToList();
+                    _levelTrace = levelFields.First(x => x.Name == "Trace").GetValue(null);
+                    _levelDebug = levelFields.First(x => x.Name == "Debug").GetValue(null);
+                    _levelInfo = levelFields.First(x => x.Name == "Info").GetValue(null);
+                    _levelWarn = levelFields.First(x => x.Name == "Warn").GetValue(null);
+                    _levelError = levelFields.First(x => x.Name == "Error").GetValue(null);
+                    _levelFatal = levelFields.First(x => x.Name == "Fatal").GetValue(null);
+
+                    var logEventInfoType = Type.GetType("NLog.LogEventInfo, NLog");
+                    if (logEventInfoType == null)
+                    {
+                        throw new InvalidOperationException("Type NLog.LogEventInfo was not found.");
+                    }
+                    MethodInfo createLogEventInfoMethodInfo = logEventInfoType.GetMethodPortable("Create",
+                        logEventLevelType, typeof(string), typeof(Exception), typeof(IFormatProvider), typeof(string), typeof(object[]));
+                    ParameterExpression loggerNameParam = Expression.Parameter(typeof(string));
+                    ParameterExpression levelParam = Expression.Parameter(typeof(object));
+                    ParameterExpression messageParam = Expression.Parameter(typeof(string));
+                    ParameterExpression exceptionParam = Expression.Parameter(typeof(Exception));
+                    UnaryExpression levelCast = Expression.Convert(levelParam, logEventLevelType);
+                    MethodCallExpression createLogEventInfoMethodCall = Expression.Call(null,
+                        createLogEventInfoMethodInfo,
+                        levelCast, loggerNameParam, exceptionParam,
+                        Expression.Constant(null, typeof(IFormatProvider)), messageParam, Expression.Constant(null, typeof(object[])));
+                    _logEventInfoFact = Expression.Lambda<Func<string, object, string, Exception, object>>(createLogEventInfoMethodCall,
+                        loggerNameParam, levelParam, messageParam, exceptionParam).Compile();
+                }
+                catch { }
+            }
+
             internal NLogLogger(dynamic logger)
             {
                 _logger = logger;
@@ -885,6 +922,43 @@ public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception
                 }
                 messageFunc = LogMessageFormatter.SimulateStructuredLogging(messageFunc, formatParameters);
 
+                if (_logEventInfoFact != null)
+                {
+                    if (IsLogLevelEnable(logLevel))
+                    {
+                        var nlogLevel = this.TranslateLevel(logLevel);
+                        Type s_callerStackBoundaryType;
+#if !LIBLOG_PORTABLE
+                        StackTrace stack = new StackTrace();
+                        Type thisType = GetType();
+                        Type knownType0 = typeof(LoggerExecutionWrapper);
+                        Type knownType1 = typeof(LogExtensions);
+                        //Maybe inline, so we may can't found any LibLog classes in stack
+                        s_callerStackBoundaryType = null;
+                        for (var i = 0; i < stack.FrameCount; i++)
+                        {
+                            var declaringType = stack.GetFrame(i).GetMethod().DeclaringType;
+                            if (!IsInTypeHierarchy(thisType, declaringType) &&
+                                !IsInTypeHierarchy(knownType0, declaringType) &&
+                                !IsInTypeHierarchy(knownType1, declaringType))
+                            {
+                                if (i > 1)
+                                    s_callerStackBoundaryType = stack.GetFrame(i - 1).GetMethod().DeclaringType;
+                                break;
+                            }
+                        }
+#else
+                        s_callerStackBoundaryType = null;
+#endif
+                        if (s_callerStackBoundaryType != null)
+                            _logger.Log(s_callerStackBoundaryType, _logEventInfoFact(_logger.Name, nlogLevel, messageFunc(), exception));
+                        else
+                            _logger.Log(_logEventInfoFact(_logger.Name, nlogLevel, messageFunc(), exception));
+                        return true;
+                    }
+                    return false;
+                }
+
                 if(exception != null)
                 {
                     return LogException(logLevel, messageFunc, exception);
@@ -937,6 +1011,19 @@ public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception
                 return false;
             }
 
+            private static bool IsInTypeHierarchy(Type currentType, Type checkType)
+            {
+                while (currentType != null && currentType != typeof(object))
+                {
+                    if (currentType == checkType)
+                    {
+                        return true;
+                    }
+                    currentType = currentType.GetBaseTypePortable();
+                }
+                return false;
+            }
+
             [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
             private bool LogException(LogLevel logLevel, Func<string> messageFunc, Exception exception)
             {
@@ -1006,6 +1093,27 @@ private bool IsLogLevelEnable(LogLevel logLevel)
                         return _logger.IsTraceEnabled;
                 }
             }
+
+            private object TranslateLevel(LogLevel logLevel)
+            {
+                switch (logLevel)
+                {
+                    case LogLevel.Trace:
+                        return _levelTrace;
+                    case LogLevel.Debug:
+                        return _levelDebug;
+                    case LogLevel.Info:
+                        return _levelInfo;
+                    case LogLevel.Warn:
+                        return _levelWarn;
+                    case LogLevel.Error:
+                        return _levelError;
+                    case LogLevel.Fatal:
+                        return _levelFatal;
+                    default:
+                        throw new ArgumentOutOfRangeException("logLevel", logLevel, null);
+                }
+            }
         }
     }
 
@@ -1129,7 +1237,9 @@ internal class Log4NetLogger
             private readonly object _levelError;
             private readonly object _levelFatal;
             private readonly Func<object, object, bool> _isEnabledForDelegate;
-            private readonly Action<object, Type, object, string, Exception> _logDelegate;
+            private readonly Action<object, object> _logDelegate;
+            private readonly Func<object, Type, object, string, Exception, object> _createLoggingEvent;
+            private Action<object, string, object> _loggingEventPropertySetter;
 
             [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "ILogger")]
             internal Log4NetLogger(dynamic logger)
@@ -1155,38 +1265,123 @@ internal Log4NetLogger(dynamic logger)
                 {
                     throw new InvalidOperationException("Type log4net.Core.ILogger, was not found.");
                 }
-                MethodInfo isEnabledMethodInfo = loggerType.GetMethodPortable("IsEnabledFor", logEventLevelType);
                 ParameterExpression instanceParam = Expression.Parameter(typeof(object));
                 UnaryExpression instanceCast = Expression.Convert(instanceParam, loggerType);
-                ParameterExpression callerStackBoundaryDeclaringTypeParam = Expression.Parameter(typeof(Type));
                 ParameterExpression levelParam = Expression.Parameter(typeof(object));
-                ParameterExpression messageParam = Expression.Parameter(typeof(string));
                 UnaryExpression levelCast = Expression.Convert(levelParam, logEventLevelType);
-                MethodCallExpression isEnabledMethodCall = Expression.Call(instanceCast, isEnabledMethodInfo, levelCast);
-                _isEnabledForDelegate = Expression.Lambda<Func<object, object, bool>>(isEnabledMethodCall, instanceParam, levelParam).Compile();
+                _isEnabledForDelegate = GetIsEnabledFor(loggerType, logEventLevelType, instanceCast, levelCast, instanceParam, levelParam);
+
+                Type loggingEventType = Type.GetType("log4net.Core.LoggingEvent, log4net");
+
+                _createLoggingEvent = GetCreateLoggingEvent(instanceParam, instanceCast, levelParam, levelCast, loggingEventType);
+
+                _logDelegate = GetLogDelegate(loggerType, loggingEventType, instanceCast, instanceParam);
 
-                // Action<object, object, string, Exception> Log =
-                // (logger, callerStackBoundaryDeclaringType, level, message, exception) => { ((ILogger)logger).Write(callerStackBoundaryDeclaringType, level, message, exception); }
+                _loggingEventPropertySetter = GetLoggingEventPropertySetter(loggingEventType);
+            }
+
+            private static Action<object, object> GetLogDelegate(Type loggerType, Type loggingEventType, UnaryExpression instanceCast,
+                                                 ParameterExpression instanceParam)
+            {
+                //Action<object, object, string, Exception> Log =
+                //(logger, callerStackBoundaryDeclaringType, level, message, exception) => { ((ILogger)logger).Log(new LoggingEvent(callerStackBoundaryDeclaringType, logger.Repository, logger.Name, level, message, exception)); }
                 MethodInfo writeExceptionMethodInfo = loggerType.GetMethodPortable("Log",
-                    typeof(Type),
-                    logEventLevelType,
-                    typeof(string),
-                    typeof(Exception));
-                ParameterExpression exceptionParam = Expression.Parameter(typeof(Exception));
+                                                                                   loggingEventType);
+
+                ParameterExpression loggingEventParameter =
+                    Expression.Parameter(typeof(object), "loggingEvent");
+
+                UnaryExpression loggingEventCasted =
+                    Expression.Convert(loggingEventParameter, loggingEventType);
+
                 var writeMethodExp = Expression.Call(
                     instanceCast,
                     writeExceptionMethodInfo,
-                    callerStackBoundaryDeclaringTypeParam,
-                    levelCast,
-                    messageParam,
-                    exceptionParam);
-                _logDelegate = Expression.Lambda<Action<object, Type, object, string, Exception>>(
-                    writeMethodExp,
-                    instanceParam,
-                    callerStackBoundaryDeclaringTypeParam,
-                    levelParam,
-                    messageParam,
-                    exceptionParam).Compile();
+                    loggingEventCasted);
+
+                var logDelegate = Expression.Lambda<Action<object, object>>(
+                                                writeMethodExp,
+                                                instanceParam,
+                                                loggingEventParameter).Compile();
+
+                return logDelegate;
+            }
+
+            private static Func<object, Type, object, string, Exception, object> GetCreateLoggingEvent(ParameterExpression instanceParam, UnaryExpression instanceCast, ParameterExpression levelParam, UnaryExpression levelCast, Type loggingEventType)
+            {
+                ParameterExpression callerStackBoundaryDeclaringTypeParam = Expression.Parameter(typeof(Type));
+                ParameterExpression messageParam = Expression.Parameter(typeof(string));
+                ParameterExpression exceptionParam = Expression.Parameter(typeof(Exception));
+
+                PropertyInfo repositoryProperty = loggingEventType.GetPropertyPortable("Repository");
+                PropertyInfo levelProperty = loggingEventType.GetPropertyPortable("Level");
+
+                ConstructorInfo loggingEventConstructor =
+                    loggingEventType.GetConstructorPortable(typeof(Type), repositoryProperty.PropertyType, typeof(string), levelProperty.PropertyType, typeof(object), typeof(Exception));
+
+                //Func<object, object, string, Exception, object> Log =
+                //(logger, callerStackBoundaryDeclaringType, level, message, exception) => new LoggingEvent(callerStackBoundaryDeclaringType, ((ILogger)logger).Repository, ((ILogger)logger).Name, (Level)level, message, exception); }
+                NewExpression newLoggingEventExpression =
+                    Expression.New(loggingEventConstructor,
+                                   callerStackBoundaryDeclaringTypeParam,
+                                   Expression.Property(instanceCast, "Repository"),
+                                   Expression.Property(instanceCast, "Name"),
+                                   levelCast,
+                                   messageParam,
+                                   exceptionParam);
+
+                var createLoggingEvent =
+                    Expression.Lambda<Func<object, Type, object, string, Exception, object>>(
+                                  newLoggingEventExpression,
+                                  instanceParam,
+                                  callerStackBoundaryDeclaringTypeParam,
+                                  levelParam,
+                                  messageParam,
+                                  exceptionParam)
+                              .Compile();
+
+                return createLoggingEvent;
+            }
+
+            private static Func<object, object, bool> GetIsEnabledFor(Type loggerType, Type logEventLevelType,
+                                                                      UnaryExpression instanceCast,
+                                                                      UnaryExpression levelCast,
+                                                                      ParameterExpression instanceParam,
+                                                                      ParameterExpression levelParam)
+            {
+                MethodInfo isEnabledMethodInfo = loggerType.GetMethodPortable("IsEnabledFor", logEventLevelType);
+                MethodCallExpression isEnabledMethodCall = Expression.Call(instanceCast, isEnabledMethodInfo, levelCast);
+
+                Func<object, object, bool> result =
+                    Expression.Lambda<Func<object, object, bool>>(isEnabledMethodCall, instanceParam, levelParam)
+                              .Compile();
+
+                return result;
+            }
+
+            private static Action<object, string, object> GetLoggingEventPropertySetter(Type loggingEventType)
+            {
+                ParameterExpression loggingEventParameter = Expression.Parameter(typeof(object), "loggingEvent");
+                ParameterExpression keyParameter = Expression.Parameter(typeof(string), "key");
+                ParameterExpression valueParameter = Expression.Parameter(typeof(object), "value");
+
+                PropertyInfo propertiesProperty = loggingEventType.GetPropertyPortable("Properties");
+                PropertyInfo item = propertiesProperty.PropertyType.GetPropertyPortable("Item");
+
+                // ((LoggingEvent)loggingEvent).Properties[key] = value;
+                var body =
+                    Expression.Assign(
+                        Expression.Property(
+                            Expression.Property(Expression.Convert(loggingEventParameter, loggingEventType),
+                                                propertiesProperty), item, keyParameter), valueParameter);
+
+                Action<object, string, object> result =
+                    Expression.Lambda<Action<object, string, object>>
+                              (body, loggingEventParameter, keyParameter,
+                               valueParameter)
+                              .Compile();
+
+                return result;
             }
 
             public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception, params object[] formatParameters)
@@ -1201,7 +1396,14 @@ public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception
                     return false;
                 }
 
-                messageFunc = LogMessageFormatter.SimulateStructuredLogging(messageFunc, formatParameters);
+                string message = messageFunc();
+
+                IEnumerable<string> patternMatches;
+
+                string formattedMessage =
+                    LogMessageFormatter.FormatStructuredMessage(message,
+                                                                formatParameters,
+                                                                out patternMatches);
 
                 // determine correct caller - this might change due to jit optimizations with method inlining
                 if (s_callerStackBoundaryType == null)
@@ -1227,10 +1429,28 @@ public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception
                 }
 
                 var translatedLevel = TranslateLevel(logLevel);
-                _logDelegate(_logger, s_callerStackBoundaryType, translatedLevel, messageFunc(), exception);
+
+                object loggingEvent = _createLoggingEvent(_logger, s_callerStackBoundaryType, translatedLevel, formattedMessage, exception);
+
+                PopulateProperties(loggingEvent, patternMatches, formatParameters);
+
+                _logDelegate(_logger, loggingEvent);
+
                 return true;
             }
 
+            private void PopulateProperties(object loggingEvent, IEnumerable<string> patternMatches, object[] formatParameters)
+            {
+                IEnumerable<KeyValuePair<string, object>> keyToValue =
+                    patternMatches.Zip(formatParameters,
+                                       (key, value) => new KeyValuePair<string, object>(key, value));
+
+                foreach (KeyValuePair<string, object> keyValuePair in keyToValue)
+                {
+                    _loggingEventPropertySetter(loggingEvent, keyValuePair.Key, keyValuePair.Value);
+                }
+            }
+
             private static bool IsInTypeHierarchy(Type currentType, Type checkType)
             {
                 while (currentType != null && currentType != typeof(object))
@@ -1373,7 +1593,7 @@ private static MemberInitExpression GetWriteLogExpression(Expression message,
             Expression severityParameter, ParameterExpression logNameParameter)
         {
             var entryType = LogEntryType;
-            MemberInitExpression memberInit = Expression.MemberInit(Expression.New(entryType), 
+            MemberInitExpression memberInit = Expression.MemberInit(Expression.New(entryType),
                 Expression.Bind(entryType.GetPropertyPortable("Message"), message),
                 Expression.Bind(entryType.GetPropertyPortable("Severity"), severityParameter),
                 Expression.Bind(
@@ -1489,12 +1709,15 @@ protected override OpenMdc GetOpenMdcMethod()
 
         private static Func<string, string, IDisposable> GetPushProperty()
         {
-            Type ndcContextType = Type.GetType("Serilog.Context.LogContext, Serilog.FullNetFx");
+            Type ndcContextType = Type.GetType("Serilog.Context.LogContext, Serilog") ?? 
+                                  Type.GetType("Serilog.Context.LogContext, Serilog.FullNetFx");
+
             MethodInfo pushPropertyMethod = ndcContextType.GetMethodPortable(
                 "PushProperty", 
                 typeof(string),
                 typeof(object),
                 typeof(bool));
+
             ParameterExpression nameParam = Expression.Parameter(typeof(string), "name");
             ParameterExpression valueParam = Expression.Parameter(typeof(object), "value");
             ParameterExpression destructureObjectParam = Expression.Parameter(typeof(bool), "destructureObjects");
@@ -1849,7 +2072,12 @@ static TraceEventTypeValues()
 
     internal static class LogMessageFormatter
     {
-        private static readonly Regex Pattern = new Regex(@"\{@?\w{1,}\}");
+        //private static readonly Regex Pattern = new Regex(@"\{@?\w{1,}\}");
+#if LIBLOG_PORTABLE
+        private static readonly Regex Pattern = new Regex(@"(?<!{){@?(?<arg>[^\d{][^ }]*)}");
+#else
+        private static readonly Regex Pattern = new Regex(@"(?<!{){@?(?<arg>[^ :{}]+)(?<format>:[^}]+)?}", RegexOptions.Compiled);
+#endif
 
         /// <summary>
         /// Some logging frameworks support structured logging, such as serilog. This will allow you to add names to structured data in a format string:
@@ -1871,24 +2099,8 @@ public static Func<string> SimulateStructuredLogging(Func<string> messageBuilder
             return () =>
             {
                 string targetMessage = messageBuilder();
-                int argumentIndex = 0;
-                foreach (Match match in Pattern.Matches(targetMessage))
-                {
-                    int notUsed;
-                    if (!int.TryParse(match.Value.Substring(1, match.Value.Length -2), out notUsed))
-                    {
-                        targetMessage = ReplaceFirst(targetMessage, match.Value,
-                            "{" + argumentIndex++ + "}");
-                    }
-                }
-                try
-                {
-                    return string.Format(CultureInfo.InvariantCulture, targetMessage, formatParameters);
-                }
-                catch (FormatException ex)
-                {
-                    throw new FormatException("The input string '" + targetMessage + "' could not be formatted using string.Format", ex);
-                }
+                IEnumerable<string> patternMatches;
+                return FormatStructuredMessage(targetMessage, formatParameters, out patternMatches);
             };
         }
 
@@ -1901,10 +2113,62 @@ private static string ReplaceFirst(string text, string search, string replace)
             }
             return text.Substring(0, pos) + replace + text.Substring(pos + search.Length);
         }
+
+        public static string FormatStructuredMessage(string targetMessage, object[] formatParameters, out IEnumerable<string> patternMatches)
+        {
+            if (formatParameters.Length == 0)
+            {
+                patternMatches = Enumerable.Empty<string>();
+                return targetMessage;
+            }
+
+            List<string> processedArguments = new List<string>();
+            patternMatches = processedArguments;
+
+            foreach (Match match in Pattern.Matches(targetMessage))
+            {
+                var arg = match.Groups["arg"].Value;
+
+                int notUsed;
+                if (!int.TryParse(arg, out notUsed))
+                {
+                    int argumentIndex = processedArguments.IndexOf(arg);
+                    if (argumentIndex == -1)
+                    {
+                        argumentIndex = processedArguments.Count;
+                        processedArguments.Add(arg);
+                    }
+
+                    targetMessage = ReplaceFirst(targetMessage, match.Value,
+                        "{" + argumentIndex + match.Groups["format"].Value + "}");
+                }
+            }
+            try
+            {
+                return string.Format(CultureInfo.InvariantCulture, targetMessage, formatParameters);
+            }
+            catch (FormatException ex)
+            {
+                throw new FormatException("The input string '" + targetMessage + "' could not be formatted using string.Format", ex);
+            }
+        }
     }
 
     internal static class TypeExtensions
     {
+        internal static ConstructorInfo GetConstructorPortable(this Type type, params Type[] types)
+        {
+#if LIBLOG_PORTABLE
+            return type.GetTypeInfo().DeclaredConstructors.FirstOrDefault
+                       (constructor =>
+                            constructor.GetParameters()
+                                       .Select(parameter => parameter.ParameterType)
+                                       .SequenceEqual(types));
+#else
+            return type.GetConstructor(types);
+#endif
+        }
+
         internal static MethodInfo GetMethodPortable(this Type type, string name)
         {
 #if LIBLOG_PORTABLE
diff --git a/src/Medidata.ZipkinTracer.Core/Helpers/ParserHelper.cs b/src/Medidata.ZipkinTracer.Core/Helpers/ParserHelper.cs
new file mode 100644
index 0000000..00cbfa1
--- /dev/null
+++ b/src/Medidata.ZipkinTracer.Core/Helpers/ParserHelper.cs
@@ -0,0 +1,41 @@
+using System;
+using System.Globalization;
+
+namespace Medidata.ZipkinTracer.Core.Helpers
+{
+    internal static class ParserHelper
+    {
+        /// <summary>
+        /// Checks if string value can be converted to 128bit (Guid) or 64bit (long)
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        internal static bool IsParsableTo128Or64Bit(this string value)
+        {
+            if (value.IsParsableToGuid()) return true;
+            return value.IsParsableToLong();
+        }
+
+        /// <summary>
+        /// Checks if hex string value is parsable to Guid
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        internal static bool IsParsableToGuid(this string value)
+        {
+            Guid result;
+            return Guid.TryParseExact(value, "N", out result);
+        }
+
+        /// <summary>
+        /// Checks if hex string value is parsable to long
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        internal static bool IsParsableToLong(this string value)
+        {
+            long result;
+            return !string.IsNullOrWhiteSpace(value) && long.TryParse(value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out result);
+        }
+    }
+}
diff --git a/src/Medidata.ZipkinTracer.Core/IZipkinConfig.cs b/src/Medidata.ZipkinTracer.Core/IZipkinConfig.cs
index 6f4b17e..a4bd6f3 100644
--- a/src/Medidata.ZipkinTracer.Core/IZipkinConfig.cs
+++ b/src/Medidata.ZipkinTracer.Core/IZipkinConfig.cs
@@ -20,6 +20,8 @@ public interface IZipkinConfig
 
         IList<string> NotToBeDisplayedDomainList { get; set; }
 
+        bool Create128BitTraceId { get; set; }
+
         bool ShouldBeSampled(IOwinContext context, string sampled);
 
         void Validate();
diff --git a/src/Medidata.ZipkinTracer.Core/Medidata.ZipkinTracer.Core.csproj b/src/Medidata.ZipkinTracer.Core/Medidata.ZipkinTracer.Core.csproj
index b1fb947..5050e4d 100644
--- a/src/Medidata.ZipkinTracer.Core/Medidata.ZipkinTracer.Core.csproj
+++ b/src/Medidata.ZipkinTracer.Core/Medidata.ZipkinTracer.Core.csproj
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\..\packages\Microsoft.Net.Compilers.1.3.2\build\Microsoft.Net.Compilers.props" Condition="Exists('..\..\packages\Microsoft.Net.Compilers.1.3.2\build\Microsoft.Net.Compilers.props')" />
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -13,6 +14,8 @@
     <FileAlignment>512</FileAlignment>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">.\</SolutionDir>
     <RestorePackages>true</RestorePackages>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -36,8 +39,8 @@
       <HintPath>..\..\packages\Microsoft.Owin.3.0.1\lib\net45\Microsoft.Owin.dll</HintPath>
       <Private>True</Private>
     </Reference>
-    <Reference Include="Newtonsoft.Json, Version=8.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Newtonsoft.Json.8.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
+    <Reference Include="Newtonsoft.Json, Version=9.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Newtonsoft.Json.9.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="Owin, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f0ebd12fd5e55cc5, processorArchitecture=MSIL">
@@ -56,8 +59,9 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Helpers\SyncHelper.cs" />
     <Compile Include="App_Packages\LibLog.4.2\LibLog.cs" />
+    <Compile Include="Helpers\ParserHelper.cs" />
+    <Compile Include="Helpers\SyncHelper.cs" />
     <Compile Include="ITraceProvider.cs" />
     <Compile Include="ITracerClient.cs" />
     <Compile Include="IZipkinConfig.cs" />
@@ -99,6 +103,12 @@
     <PostBuildEvent>
     </PostBuildEvent>
   </PropertyGroup>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\..\packages\Microsoft.Net.Compilers.1.3.2\build\Microsoft.Net.Compilers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\Microsoft.Net.Compilers.1.3.2\build\Microsoft.Net.Compilers.props'))" />
+  </Target>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/src/Medidata.ZipkinTracer.Core/Models/Serialization/Json/JsonSpan.cs b/src/Medidata.ZipkinTracer.Core/Models/Serialization/Json/JsonSpan.cs
index 2e94e59..5717789 100644
--- a/src/Medidata.ZipkinTracer.Core/Models/Serialization/Json/JsonSpan.cs
+++ b/src/Medidata.ZipkinTracer.Core/Models/Serialization/Json/JsonSpan.cs
@@ -10,16 +10,16 @@ internal class JsonSpan
         private readonly Span span;
 
         [JsonProperty("traceId")]
-        public string TraceId => span.TraceId.ToString("x4");
+        public string TraceId => span.TraceId;
 
         [JsonProperty("name")]
         public string Name => span.Name;
 
         [JsonProperty("id")]
-        public string Id => span.Id.ToString("x4");
+        public string Id => span.Id;
 
         [JsonProperty("parentId", NullValueHandling = NullValueHandling.Ignore)]
-        public string ParentId => span.ParentId?.ToString("x4");
+        public string ParentId => string.IsNullOrWhiteSpace(span.ParentId) ? null : span.ParentId;
 
         [JsonProperty("annotations")]
         public IEnumerable<JsonAnnotation> Annotations =>
diff --git a/src/Medidata.ZipkinTracer.Core/Models/Span.cs b/src/Medidata.ZipkinTracer.Core/Models/Span.cs
index 4b21801..5c34e0a 100644
--- a/src/Medidata.ZipkinTracer.Core/Models/Span.cs
+++ b/src/Medidata.ZipkinTracer.Core/Models/Span.cs
@@ -1,16 +1,17 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 
 namespace Medidata.ZipkinTracer.Models
 {
     public class Span
     {
-        public long TraceId { get; set; }
+        public string TraceId { get; set; }
 
         public string Name { get; set; }
 
-        public long Id { get; set; }
+        public string Id { get; set; }
 
-        public long? ParentId { get; set; }
+        public string ParentId { get; set; }
 
         public IList<AnnotationBase> Annotations { get; } = new List<AnnotationBase>();
     }
diff --git a/src/Medidata.ZipkinTracer.Core/Properties/AssemblyInfo.cs b/src/Medidata.ZipkinTracer.Core/Properties/AssemblyInfo.cs
index 223a101..14c028e 100644
--- a/src/Medidata.ZipkinTracer.Core/Properties/AssemblyInfo.cs
+++ b/src/Medidata.ZipkinTracer.Core/Properties/AssemblyInfo.cs
@@ -37,7 +37,7 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("3.1.0")]
-[assembly: AssemblyFileVersion("3.1.0")]
-[assembly: AssemblyInformationalVersion("3.1.0")]
+[assembly: AssemblyVersion("3.2.0")]
+[assembly: AssemblyFileVersion("3.2.0")]
+[assembly: AssemblyInformationalVersion("3.2.0")]
 [assembly: InternalsVisibleTo("Medidata.ZipkinTracer.Core.Test")]
\ No newline at end of file
diff --git a/src/Medidata.ZipkinTracer.Core/SpanCollector.cs b/src/Medidata.ZipkinTracer.Core/SpanCollector.cs
index 0776e52..889d197 100644
--- a/src/Medidata.ZipkinTracer.Core/SpanCollector.cs
+++ b/src/Medidata.ZipkinTracer.Core/SpanCollector.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Concurrent;
-using Medidata.ZipkinTracer.Core.Logging;
 using Medidata.ZipkinTracer.Models;
 using Medidata.ZipkinTracer.Core.Helpers;
 
diff --git a/src/Medidata.ZipkinTracer.Core/SpanTracer.cs b/src/Medidata.ZipkinTracer.Core/SpanTracer.cs
index 3a7ecfc..9afa2b9 100644
--- a/src/Medidata.ZipkinTracer.Core/SpanTracer.cs
+++ b/src/Medidata.ZipkinTracer.Core/SpanTracer.cs
@@ -48,7 +48,7 @@ public virtual void SendServerSpan(Span span)
         {
             if (span == null)
             {
-                throw new ArgumentNullException("Null server span");
+                throw new ArgumentNullException(nameof(span));
             }
 
             if (span.Annotations == null || !span.Annotations.Any())
@@ -103,7 +103,7 @@ public virtual void ReceiveClientSpan(Span span, int statusCode)
         {
             if (span == null)
             {
-                throw new ArgumentNullException("Null client span");
+                throw new ArgumentNullException(nameof(span));
             }
 
             if (span.Annotations == null || !span.Annotations.Any())
@@ -126,7 +126,7 @@ public virtual void ReceiveClientSpan(Span span, int statusCode)
         public virtual void Record(Span span, string value)
         {
             if (span == null)
-                throw new ArgumentNullException("span", "In order to record an annotation, the span must be not null.");
+                throw new ArgumentNullException(nameof(span), "In order to record an annotation, the span must be not null.");
 
             span.Annotations.Add(new Annotation()
             {
@@ -138,7 +138,7 @@ public virtual void Record(Span span, string value)
         public void RecordBinary<T>(Span span, string key, T value)
         {
              if (span == null)
-                throw new ArgumentNullException("span", "In order to record a binary annotation, the span must be not null.");
+                throw new ArgumentNullException(nameof(span), "In order to record a binary annotation, the span must be not null.");
 
             span.Annotations.Add(new BinaryAnnotation()
             {
@@ -148,19 +148,15 @@ public void RecordBinary<T>(Span span, string key, T value)
             });
         }
 
-        private Span CreateNewSpan(string spanName, string traceId, string parentSpanId, string spanId)
+        internal static Span CreateNewSpan(string spanName, string traceId, string parentSpanId, string spanId)
         {
-            var newSpan = new Span();
-            newSpan.Id = Int64.Parse(spanId, System.Globalization.NumberStyles.HexNumber);
-            newSpan.TraceId = Int64.Parse(traceId, System.Globalization.NumberStyles.HexNumber);
-
-            if (!String.IsNullOrEmpty(parentSpanId))
+            return new Span
             {
-                newSpan.ParentId = Int64.Parse(parentSpanId, System.Globalization.NumberStyles.HexNumber);
-            }
-
-            newSpan.Name = spanName;
-            return newSpan;
+                Name = spanName,
+                TraceId = traceId,
+                ParentId = parentSpanId,
+                Id = spanId
+            };
         }
 
         private void AddBinaryAnnotation<T>(string key, T value, Span span, Endpoint endpoint)
diff --git a/src/Medidata.ZipkinTracer.Core/TraceProvider.cs b/src/Medidata.ZipkinTracer.Core/TraceProvider.cs
index b96dd39..0691078 100644
--- a/src/Medidata.ZipkinTracer.Core/TraceProvider.cs
+++ b/src/Medidata.ZipkinTracer.Core/TraceProvider.cs
@@ -1,6 +1,6 @@
 using System;
-using System.Globalization;
 using Microsoft.Owin;
+using Medidata.ZipkinTracer.Core.Helpers;
 
 namespace Medidata.ZipkinTracer.Core
 {
@@ -39,6 +39,7 @@ internal class TraceProvider : ITraceProvider
         /// </summary>
         public bool IsSampled { get; }
 
+        // TODO: Make another constructor to accept System.Web.HttpContext for non Owin applications
         /// <summary>
         /// Initializes a new instance of the TraceProvider class.
         /// </summary>
@@ -71,12 +72,12 @@ internal TraceProvider(IZipkinConfig config, IOwinContext context = null)
                 headerParentSpanId = context.Request.Headers[ParentSpanIdHeaderName];
                 headerSampled = context.Request.Headers[SampledHeaderName];
             }
-
-            TraceId = Parse(headerTraceId) ? headerTraceId : GenerateHexEncodedInt64FromNewGuid();
-            SpanId = Parse(headerSpanId) ? headerSpanId : TraceId;
-            ParentSpanId = Parse(headerParentSpanId) ? headerParentSpanId : string.Empty;
+            
+            TraceId = headerTraceId.IsParsableTo128Or64Bit() ? headerTraceId : GenerateNewTraceId(config.Create128BitTraceId);
+            SpanId = headerSpanId.IsParsableToLong() ? headerSpanId : GenerateHexEncodedInt64Id();
+            ParentSpanId = headerParentSpanId.IsParsableToLong() ? headerParentSpanId : string.Empty;
             IsSampled = config.ShouldBeSampled(context, headerSampled);
-           
+            
             if (SpanId == ParentSpanId)
             {
                 throw new ArgumentException("x-b3-SpanId and x-b3-ParentSpanId must not be the same value.");
@@ -108,27 +109,29 @@ public ITraceProvider GetNext()
         {
             return new TraceProvider(
                 TraceId,
-                GenerateHexEncodedInt64FromNewGuid(),
+                GenerateHexEncodedInt64Id(),
                 SpanId,
                 IsSampled);
         }
 
         /// <summary>
-        /// Parse id value
+        /// Generate a traceId.
         /// </summary>
-        /// <param name="value">header's value</param>
-        /// <returns>true: parsed</returns>
-        private bool Parse(string value)
+        /// <param name="create128Bit">true for 128bit, false for 64 bit</param>
+        /// <returns></returns>
+        private string GenerateNewTraceId(bool create128Bit)
         {
-            long result;
-            return !string.IsNullOrWhiteSpace(value) && Int64.TryParse(value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out result);
+            if (create128Bit)
+                return Guid.NewGuid().ToString("N");
+            else
+                return GenerateHexEncodedInt64Id();
         }
 
         /// <summary>
         /// Generate a hex encoded Int64 from new Guid.
         /// </summary>
         /// <returns>The hex encoded int64</returns>
-        private string GenerateHexEncodedInt64FromNewGuid()
+        private string GenerateHexEncodedInt64Id()
         {
             return Convert.ToString(BitConverter.ToInt64(Guid.NewGuid().ToByteArray(), 0), 16);
         }
diff --git a/src/Medidata.ZipkinTracer.Core/ZipkinConfig.cs b/src/Medidata.ZipkinTracer.Core/ZipkinConfig.cs
index ca139a2..5686f39 100644
--- a/src/Medidata.ZipkinTracer.Core/ZipkinConfig.cs
+++ b/src/Medidata.ZipkinTracer.Core/ZipkinConfig.cs
@@ -14,6 +14,7 @@ public class ZipkinConfig : IZipkinConfig
         public IList<string> ExcludedPathList { get; set; } = new List<string>();
         public double SampleRate { get; set; }
         public IList<string> NotToBeDisplayedDomainList { get; set; } = new List<string>();
+        public bool Create128BitTraceId { get; set; }
 
         public void Validate()
         {
diff --git a/src/Medidata.ZipkinTracer.Core/packages.config b/src/Medidata.ZipkinTracer.Core/packages.config
index 8d39287..f817e35 100644
--- a/src/Medidata.ZipkinTracer.Core/packages.config
+++ b/src/Medidata.ZipkinTracer.Core/packages.config
@@ -1,7 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="LibLog" version="4.2.5" targetFramework="net45" developmentDependency="true" />
+  <package id="LibLog" version="4.2.6" targetFramework="net45" developmentDependency="true" />
+  <package id="Microsoft.Net.Compilers" version="1.3.2" targetFramework="net45" developmentDependency="true" />
   <package id="Microsoft.Owin" version="3.0.1" targetFramework="net45" />
-  <package id="Newtonsoft.Json" version="8.0.3" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="9.0.1" targetFramework="net45" />
   <package id="Owin" version="1.0" targetFramework="net45" />
 </packages>
\ No newline at end of file
diff --git a/tests/Medidata.ZipkinTracer.Core.Test/Helpers/ParserHelperTests.cs b/tests/Medidata.ZipkinTracer.Core.Test/Helpers/ParserHelperTests.cs
new file mode 100644
index 0000000..2856419
--- /dev/null
+++ b/tests/Medidata.ZipkinTracer.Core.Test/Helpers/ParserHelperTests.cs
@@ -0,0 +1,235 @@
+using Medidata.ZipkinTracer.Core.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+
+namespace Medidata.ZipkinTracer.Core.Test.Helpers
+{
+    [TestClass]
+    public class ParserHelperTests
+    {
+        #region IsParsableTo128Or64Bit
+
+        [TestMethod]
+        public void IsParsableTo128Or64Bit_ValidLongHexStringRepresentation()
+        {
+            // Arrange
+            string value = long.MaxValue.ToString("x");
+
+            // Act
+            var result = ParserHelper.IsParsableTo128Or64Bit(value);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [TestMethod]
+        public void IsParsableTo128Or64Bit_ValidGuidStringRepresentation()
+        {
+            // Arrange
+            string value = Guid.NewGuid().ToString("N");
+
+            // Act
+            var result = ParserHelper.IsParsableTo128Or64Bit(value);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [TestMethod]
+        public void IsParsableTo128Or64Bit_InvalidLongHexStringRepresentation()
+        {
+            // Arrange
+            var longStringRepresentation = long.MaxValue.ToString("x");
+            string value = longStringRepresentation.Substring(1) + "k" ;
+
+            // Act
+            var result = ParserHelper.IsParsableTo128Or64Bit(value);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        #endregion
+
+        #region IsParsableToGuid
+
+        [TestMethod]
+        public void IsParsableToGuid_Null()
+        {
+            // Arrange
+            string value = null;
+
+            // Act
+            var result = ParserHelper.IsParsableToGuid(value);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void IsParsableToGuid_WhiteSpace()
+        {
+            // Arrange
+            string value = string.Empty;
+
+            // Act
+            var result = ParserHelper.IsParsableToGuid(value);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void IsParsableToGuid_MoreThan32Characters()
+        {
+            // Arrange
+            string value = Guid.NewGuid().ToString("N") + "a";
+
+            // Act
+            var result = ParserHelper.IsParsableToGuid(value);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void IsParsableToGuid_LessThan32Characters()
+        {
+            // Arrange
+            string value = Guid.NewGuid().ToString("N").Substring(1);
+
+            // Act
+            var result = ParserHelper.IsParsableToGuid(value);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void IsParsableToGuid_32CharactersWithInvalidCharacter()
+        {
+            // Arrange
+            string value = Guid.NewGuid().ToString("N").Substring(1) + "x";
+
+            // Act
+            var result = ParserHelper.IsParsableToGuid(value);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void IsParsableToGuid_32Characters()
+        {
+            // Arrange
+            string value = Guid.NewGuid().ToString("N");
+
+            // Act
+            var result = ParserHelper.IsParsableToGuid(value);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [TestMethod]
+        public void IsParsableToGuid_GuidWithHyphens()
+        {
+            // Arrange
+            string value = Guid.NewGuid().ToString();
+
+            // Act
+            var result = ParserHelper.IsParsableToGuid(value);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        #endregion
+
+        #region IsParsableToLong
+
+        [TestMethod]
+        public void IsParsableToLong_Null()
+        {
+            // Arrange
+            string value = null;
+
+            // Act
+            var result = ParserHelper.IsParsableToLong(value);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void IsParsableToLong_WhiteSpace()
+        {
+            // Arrange
+            string value = string.Empty;
+
+            // Act
+            var result = ParserHelper.IsParsableToLong(value);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void IsParsableToLong_MinLong()
+        {
+            // Arrange
+            var longValue = long.MinValue;
+            string value = longValue.ToString("x");
+
+            // Act
+            var result = ParserHelper.IsParsableToLong(value);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [TestMethod]
+        public void IsParsableToLong_MaxLong()
+        {
+            // Arrange
+            var longValue = long.MaxValue;
+            string value = longValue.ToString("x4");
+
+            // Act
+            var result = ParserHelper.IsParsableToLong(value);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [TestMethod]
+        public void IsParsableToLong_MoreThan16Characters()
+        {
+            // Arrange
+            var longValue = long.MaxValue;
+            string value = longValue.ToString("x") + "a";
+
+            // Act
+            var result = ParserHelper.IsParsableToLong(value);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void IsParsableToLong_HasInvalidCharacter()
+        {
+            // Arrange
+            var longValue = long.MaxValue;
+            string value = longValue.ToString("x4").Remove(15) + "x";
+
+            // Act
+            var result = ParserHelper.IsParsableToLong(value);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/tests/Medidata.ZipkinTracer.Core.Test/Medidata.ZipkinTracer.Core.Test.csproj b/tests/Medidata.ZipkinTracer.Core.Test/Medidata.ZipkinTracer.Core.Test.csproj
index 4b1e7e7..2fbfeeb 100644
--- a/tests/Medidata.ZipkinTracer.Core.Test/Medidata.ZipkinTracer.Core.Test.csproj
+++ b/tests/Medidata.ZipkinTracer.Core.Test/Medidata.ZipkinTracer.Core.Test.csproj
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\..\packages\Microsoft.Net.Compilers.1.3.2\build\Microsoft.Net.Compilers.props" Condition="Exists('..\..\packages\Microsoft.Net.Compilers.1.3.2\build\Microsoft.Net.Compilers.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -18,6 +19,8 @@
     <TestProjectType>UnitTest</TestProjectType>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">.\</SolutionDir>
     <RestorePackages>true</RestorePackages>
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -42,20 +45,20 @@
       <HintPath>..\..\packages\Microsoft.Owin.3.0.1\lib\net45\Microsoft.Owin.dll</HintPath>
       <Private>True</Private>
     </Reference>
-    <Reference Include="Newtonsoft.Json, Version=8.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Newtonsoft.Json.8.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
+    <Reference Include="Newtonsoft.Json, Version=9.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Newtonsoft.Json.9.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="Owin, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f0ebd12fd5e55cc5, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Owin.1.0\lib\net40\Owin.dll</HintPath>
       <Private>True</Private>
     </Reference>
-    <Reference Include="Ploeh.AutoFixture, Version=3.43.1.0, Culture=neutral, PublicKeyToken=b24654c590009d4f, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\AutoFixture.3.43.1\lib\net40\Ploeh.AutoFixture.dll</HintPath>
+    <Reference Include="Ploeh.AutoFixture, Version=3.50.2.0, Culture=neutral, PublicKeyToken=b24654c590009d4f, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\AutoFixture.3.50.2\lib\net40\Ploeh.AutoFixture.dll</HintPath>
       <Private>True</Private>
     </Reference>
-    <Reference Include="Ploeh.AutoFixture.AutoRhinoMock, Version=3.43.1.0, Culture=neutral, PublicKeyToken=b24654c590009d4f, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\AutoFixture.AutoRhinoMocks.3.43.1\lib\net40\Ploeh.AutoFixture.AutoRhinoMock.dll</HintPath>
+    <Reference Include="Ploeh.AutoFixture.AutoRhinoMock, Version=3.50.2.0, Culture=neutral, PublicKeyToken=b24654c590009d4f, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\AutoFixture.AutoRhinoMocks.3.50.2\lib\net40\Ploeh.AutoFixture.AutoRhinoMock.dll</HintPath>
       <Private>True</Private>
     </Reference>
     <Reference Include="Rhino.Mocks, Version=3.6.0.0, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
@@ -79,6 +82,8 @@
     </Otherwise>
   </Choose>
   <ItemGroup>
+    <Compile Include="Helpers\ParserHelperTests.cs" />
+    <Compile Include="Models\Serialization\Json\JsonSpanTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SpanCollectorTests.cs" />
     <Compile Include="SpanProcessorTests.cs" />
@@ -121,6 +126,12 @@
   </Choose>
   <Import Project="$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets" Condition="Exists('$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets')" />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\..\packages\Microsoft.Net.Compilers.1.3.2\build\Microsoft.Net.Compilers.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\Microsoft.Net.Compilers.1.3.2\build\Microsoft.Net.Compilers.props'))" />
+  </Target>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/tests/Medidata.ZipkinTracer.Core.Test/Models/Serialization/Json/JsonSpanTests.cs b/tests/Medidata.ZipkinTracer.Core.Test/Models/Serialization/Json/JsonSpanTests.cs
new file mode 100644
index 0000000..d1c80ec
--- /dev/null
+++ b/tests/Medidata.ZipkinTracer.Core.Test/Models/Serialization/Json/JsonSpanTests.cs
@@ -0,0 +1,63 @@
+using Medidata.ZipkinTracer.Models;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Ploeh.AutoFixture;
+using System.Linq;
+
+namespace Medidata.ZipkinTracer.Core.Test.Models.Serialization.Json
+{
+    [TestClass]
+    public class JsonSpanTests
+    {
+        private IFixture fixture;
+
+        [TestInitialize]
+        public void Init()
+        {
+            fixture = new Fixture();
+        }
+
+        [TestMethod]
+        public void JsonSpan()
+        {
+            // Arrange
+            var span = new Span
+            {
+                Id = fixture.Create<string>(),
+                Name = fixture.Create<string>(),
+                ParentId = fixture.Create<string>(),
+                TraceId = fixture.Create<string>(),
+            };
+            span.Annotations.Add(fixture.Create<Annotation>());
+            span.Annotations.Add(fixture.Create<Annotation>());
+            span.Annotations.Add(fixture.Create<BinaryAnnotation>());
+            span.Annotations.Add(fixture.Create<BinaryAnnotation>());
+
+            // Act
+            var result = new JsonSpan(span);
+
+            // Assert
+            Assert.AreEqual(span.TraceId, result.TraceId);
+            Assert.AreEqual(span.Name, result.Name);
+            Assert.AreEqual(span.Id, result.Id);
+            Assert.AreEqual(span.ParentId, result.ParentId);
+            Assert.AreEqual(2, result.Annotations.Count());
+            Assert.AreEqual(2, result.BinaryAnnotations.Count());
+        }
+
+        [TestMethod]
+        public void JsonSpan_ParentIdIsWhiteSpace()
+        {
+            // Arrange
+            var span = new Span
+            {
+                ParentId = string.Empty
+            };
+
+            // Act
+            var result = new JsonSpan(span);
+
+            // Assert
+            Assert.IsNull(result.ParentId);
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/Medidata.ZipkinTracer.Core.Test/SpanCollectorTests.cs b/tests/Medidata.ZipkinTracer.Core.Test/SpanCollectorTests.cs
index 1747149..66f4a1b 100644
--- a/tests/Medidata.ZipkinTracer.Core.Test/SpanCollectorTests.cs
+++ b/tests/Medidata.ZipkinTracer.Core.Test/SpanCollectorTests.cs
@@ -43,15 +43,16 @@ public void CTOR_doesntReinitializeSpanCollector()
 
             Assert.IsTrue(System.Object.ReferenceEquals(SpanCollector.spanQueue, spanQueue));
         }
+
         [TestMethod]
         public void CollectSpans()
         {
             SetupSpanCollector();
 
-            var testSpanId = fixture.Create<long>(); 
-            var testTraceId = fixture.Create<long>(); 
-            var testParentSpanId = fixture.Create<long>(); 
-            var testName = fixture.Create<string>(); 
+            var testSpanId = fixture.Create<string>(); 
+            var testTraceId = fixture.Create<string>(); 
+            var testParentSpanId = fixture.Create<string>(); 
+            var testName = fixture.Create<string>();
             
             Span span = new Span();
             span.Id = testSpanId;
diff --git a/tests/Medidata.ZipkinTracer.Core.Test/SpanProcessorTests.cs b/tests/Medidata.ZipkinTracer.Core.Test/SpanProcessorTests.cs
index ef83288..bb176a8 100644
--- a/tests/Medidata.ZipkinTracer.Core.Test/SpanProcessorTests.cs
+++ b/tests/Medidata.ZipkinTracer.Core.Test/SpanProcessorTests.cs
@@ -67,7 +67,7 @@ public void Stop_RemainingGetLoggedIfCancelled()
             spanProcessor.Stub(x => x.Stop()).CallOriginalMethod(OriginalCallOptions.NoExpectation);
             taskFactory.Expect(x => x.IsTaskCancelled()).Return(true);
 
-            spanProcessor.spanQueue.Add(new Span());
+            spanProcessor.spanQueue.Add(GenerateNewSpan());
             spanProcessor.Stop();
 
             spanProcessor.AssertWasCalled(s => s.SendSpansToZipkin(Arg<string>.Is.Anything));
@@ -84,7 +84,7 @@ public void LogSubmittedSpans_DoNotIncrementSubsequentPollCountIfSpanQueueIsEmpt
         public void LogSubmittedSpans_IncrementSubsequentPollCountIfSpanQueueHasAnItemLessThanMax()
         {
             //put item in queue
-            spanProcessor.spanQueue.Add(new Span());
+            spanProcessor.spanQueue.Add(GenerateNewSpan());
             spanProcessor.LogSubmittedSpans();
 
             //Proces Log with no new items
@@ -97,7 +97,7 @@ public void LogSubmittedSpans_IncrementSubsequentPollCountIfSpanQueueHasAnItemLe
         [TestMethod]
         public void LogSubmittedSpans_WhenQueueIsSubsequentlyLessThanTheMaxBatchCountMaxTimes()
         {
-            spanProcessor.spanQueue.Add(new Span());
+            spanProcessor.spanQueue.Add(GenerateNewSpan());
             spanProcessor.LogSubmittedSpans();
             spanProcessor.subsequentPollCount = SpanProcessor.MAX_NUMBER_OF_POLLS + 1;
             spanProcessor.LogSubmittedSpans();
@@ -123,8 +123,19 @@ private void AddLogEntriesToMaxBatchSize()
         {
             for (int i = 0; i < testMaxBatchSize + 1; i++)
             {
-                spanProcessor.spanQueue.Add(new Span());
+                spanProcessor.spanQueue.Add(GenerateNewSpan());
             }
         }
+
+        private Span GenerateNewSpan()
+        {
+            return new Span
+            {
+                Id = fixture.Create<string>(),
+                Name = fixture.Create<string>(),
+                ParentId = fixture.Create<string>(),
+                TraceId = fixture.Create<string>(),
+            };
+        }
     }
 }
diff --git a/tests/Medidata.ZipkinTracer.Core.Test/SpanTracerTests.cs b/tests/Medidata.ZipkinTracer.Core.Test/SpanTracerTests.cs
index 979f1f5..91f9106 100644
--- a/tests/Medidata.ZipkinTracer.Core.Test/SpanTracerTests.cs
+++ b/tests/Medidata.ZipkinTracer.Core.Test/SpanTracerTests.cs
@@ -36,6 +36,30 @@ public void Init()
             api = "/api/method1";
         }
 
+        [TestMethod]
+        public void CreateNewSpan()
+        {
+            var spanName = fixture.Create<string>();
+            var traceId = Guid.NewGuid().ToString("N");
+            var parentSpanId = fixture.Create<long>().ToString("x");
+            var spanId = fixture.Create<long>().ToString("x");
+
+            var resultSpan = SpanTracer.CreateNewSpan(spanName, traceId, parentSpanId, spanId);
+
+            Assert.AreEqual(spanName, resultSpan.Name);
+            Assert.AreEqual(traceId, resultSpan.TraceId);
+            Assert.AreEqual(parentSpanId, resultSpan.ParentId);
+            Assert.AreEqual(spanId, resultSpan.Id);
+        }
+
+        [TestMethod]
+        public void CreateNewSpan_WithNullParentSpanId()
+        {
+            var resultSpan = SpanTracer.CreateNewSpan(fixture.Create<string>(), fixture.Create<long>().ToString(), null, fixture.Create<long>().ToString());
+
+            Assert.IsNull(resultSpan.ParentId);
+        }
+
         [TestMethod]
         [ExpectedException(typeof(ArgumentNullException))]
         public void CTOR_WithNullSpanCollector()
@@ -69,9 +93,9 @@ public void ReceiveServerSpan()
         {
             var domain = new Uri("http://server.com");
             var requestName = fixture.Create<string>();
-            var traceId = fixture.Create<long>().ToString();
-            var parentSpanId = fixture.Create<long>().ToString();
-            var spanId = fixture.Create<long>().ToString();
+            var traceId = Guid.NewGuid().ToString("N");
+            var parentSpanId = fixture.Create<long>().ToString("x");
+            var spanId = fixture.Create<long>().ToString("x");
             var serverUri = new Uri("https://" + clientServiceName + ":" + port + api);
 
             var spanTracer = new SpanTracer(spanCollectorStub, zipkinEndpointStub, zipkinNotToBeDisplayedDomainList, domain);
@@ -82,9 +106,9 @@ public void ReceiveServerSpan()
             var resultSpan = spanTracer.ReceiveServerSpan(requestName, traceId, parentSpanId, spanId, serverUri);
 
             Assert.AreEqual(requestName, resultSpan.Name);
-            Assert.AreEqual(Int64.Parse(traceId, System.Globalization.NumberStyles.HexNumber), resultSpan.TraceId);
-            Assert.AreEqual(Int64.Parse(parentSpanId, System.Globalization.NumberStyles.HexNumber), resultSpan.ParentId);
-            Assert.AreEqual(Int64.Parse(spanId, System.Globalization.NumberStyles.HexNumber), resultSpan.Id);
+            Assert.AreEqual(traceId, resultSpan.TraceId);
+            Assert.AreEqual(parentSpanId, resultSpan.ParentId);
+            Assert.AreEqual(spanId, resultSpan.Id);
 
             Assert.AreEqual(1, resultSpan.GetAnnotationsByType<Annotation>().Count());
 
@@ -106,9 +130,8 @@ public void ReceiveServerSpan()
         [TestMethod]
         public void ReceiveServerSpan_UsingToBeCleanedDomainName()
         {
-            var serverServiceName = "server";
             var requestName = fixture.Create<string>();
-            var traceId = fixture.Create<long>().ToString();
+            var traceId = fixture.Create<Guid>().ToString("N");
             var parentSpanId = fixture.Create<long>().ToString();
             var spanId = fixture.Create<long>().ToString();
             var serverUri = new Uri("https://" + clientServiceName + ":" + port + api);
@@ -131,7 +154,7 @@ public void ReceiveServerSpan_UsingAlreadyCleanedDomainName()
         {
             var domain = new Uri("https://server.com");
             var requestName = fixture.Create<string>();
-            var traceId = fixture.Create<long>().ToString();
+            var traceId = fixture.Create<Guid>().ToString("N");
             var parentSpanId = fixture.Create<long>().ToString();
             var spanId = fixture.Create<long>().ToString();
             var serverUri = new Uri("https://" + clientServiceName + ":" + port + api);
@@ -203,9 +226,9 @@ public void SendClientSpan()
         {
             var domain = new Uri("https://server.com");
             var requestName = fixture.Create<string>();
-            var traceId = fixture.Create<long>().ToString();
-            var parentSpanId = fixture.Create<long>().ToString();
-            var spanId = fixture.Create<long>().ToString();
+            var traceId = Guid.NewGuid().ToString("N");
+            var parentSpanId = fixture.Create<long>().ToString("x");
+            var spanId = fixture.Create<long>().ToString("x");
             var serverUri = new Uri("https://" + clientServiceName + ":" + port + api);
 
             var spanTracer = new SpanTracer(spanCollectorStub, zipkinEndpointStub, zipkinNotToBeDisplayedDomainList, domain);
@@ -218,9 +241,9 @@ public void SendClientSpan()
             var resultSpan = spanTracer.SendClientSpan(requestName, traceId, parentSpanId, spanId, serverUri);
 
             Assert.AreEqual(requestName, resultSpan.Name);
-            Assert.AreEqual(Int64.Parse(traceId, System.Globalization.NumberStyles.HexNumber), resultSpan.TraceId);
-            Assert.AreEqual(Int64.Parse(parentSpanId, System.Globalization.NumberStyles.HexNumber), resultSpan.ParentId);
-            Assert.AreEqual(Int64.Parse(spanId, System.Globalization.NumberStyles.HexNumber), resultSpan.Id);
+            Assert.AreEqual(traceId, resultSpan.TraceId);
+            Assert.AreEqual(parentSpanId, resultSpan.ParentId);
+            Assert.AreEqual(spanId, resultSpan.Id);
 
 
 
@@ -249,7 +272,7 @@ public void SendClientSpanWithDomainUnderFilterList()
         {
             var domain = new Uri("https://server.com");
             var requestName = fixture.Create<string>();
-            var traceId = fixture.Create<long>().ToString();
+            var traceId = fixture.Create<Guid>().ToString("N");
             var parentSpanId = fixture.Create<long>().ToString();
             var spanId = fixture.Create<long>().ToString();
             var serverUri = new Uri("https://" + clientServiceName + zipkinNotToBeDisplayedDomainList.First() + ":" + port + api);
@@ -409,4 +432,4 @@ private void AssertBinaryAnnotations(IEnumerable<BinaryAnnotation> list, string
             Assert.AreEqual(value, list.Where(x => x.Key.Equals(key)).Select(x => x.Value).First());
         }
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Medidata.ZipkinTracer.Core.Test/TraceProviderTests.cs b/tests/Medidata.ZipkinTracer.Core.Test/TraceProviderTests.cs
index 7fcfdc9..608fe6c 100644
--- a/tests/Medidata.ZipkinTracer.Core.Test/TraceProviderTests.cs
+++ b/tests/Medidata.ZipkinTracer.Core.Test/TraceProviderTests.cs
@@ -4,26 +4,78 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Ploeh.AutoFixture;
 using Rhino.Mocks;
+using System.Text.RegularExpressions;
 
 namespace Medidata.ZipkinTracer.Core.Test
 {
     [TestClass]
     public class TraceProviderTests
     {
+        private const string regex128BitPattern = @"^[a-f0-9]{32}$";
+        private const string regex64BitPattern = @"^[a-f0-9]{16}$";
+
         [TestMethod]
-        public void ConstructorWithNullContext()
+        public void Constructor_GeneratingNew64BitTraceId()
         {
+            // Arrange
+            var config = new ZipkinConfig
+            {
+                Create128BitTraceId = false
+            };
+
             // Arrange & Act
-            var traceProvider = new TraceProvider(new ZipkinConfig());
+            var traceProvider = new TraceProvider(config);
 
             // Assert
-            Assert.AreEqual(traceProvider.TraceId, traceProvider.SpanId);
+            Assert.IsTrue(Regex.IsMatch(traceProvider.TraceId, regex64BitPattern));
+            Assert.IsTrue(Regex.IsMatch(traceProvider.SpanId, regex64BitPattern));
             Assert.AreEqual(string.Empty, traceProvider.ParentSpanId);
             Assert.AreEqual(false, traceProvider.IsSampled);
         }
 
         [TestMethod]
-        public void ConstructorWithContextHavingAllIdValues()
+        public void Constructor_GeneratingNew128BitTraceId()
+        {
+            // Arrange
+            var config = new ZipkinConfig
+            {
+                Create128BitTraceId = true
+            };
+
+            // Arrange & Act
+            var traceProvider = new TraceProvider(config);
+
+            // Assert
+            Assert.IsTrue(Regex.IsMatch(traceProvider.TraceId, regex128BitPattern));
+            Assert.IsTrue(Regex.IsMatch(traceProvider.SpanId, regex64BitPattern));
+            Assert.AreEqual(string.Empty, traceProvider.ParentSpanId);
+            Assert.AreEqual(false, traceProvider.IsSampled);
+        }
+
+        [TestMethod]
+        public void Constructor_HavingTraceProviderInContext()
+        {
+            // Arrange
+            var context = MockRepository.GenerateStub<IOwinContext>();
+            var providerInContext = MockRepository.GenerateStub<ITraceProvider>();
+            var environment = new Dictionary<string, object>
+            {
+                { "Medidata.ZipkinTracer.Core.TraceProvider", providerInContext }
+            };
+            context.Stub(x => x.Environment).Return(environment);
+
+            // Act
+            var sut = new TraceProvider(new ZipkinConfig(), context);
+
+            // Assert
+            Assert.AreEqual(providerInContext.TraceId, sut.TraceId);
+            Assert.AreEqual(providerInContext.SpanId, sut.SpanId);
+            Assert.AreEqual(providerInContext.ParentSpanId, sut.ParentSpanId);
+            Assert.AreEqual(providerInContext.IsSampled, sut.IsSampled);
+        }
+
+        [TestMethod]
+        public void Constructor_AcceptingHeadersWith64BitTraceId()
         {
             // Arrange
             var fixture = new Fixture();
@@ -32,20 +84,63 @@ public void ConstructorWithContextHavingAllIdValues()
             var parentSpanId = Convert.ToString(fixture.Create<long>(), 16);
             var isSampled = fixture.Create<bool>();
 
-            var context = MockRepository.GenerateStub<IOwinContext>();
-            var request = MockRepository.GenerateStub<IOwinRequest>();
-            var headers = new HeaderDictionary(new Dictionary<string, string[]>
-            {
-                { TraceProvider.TraceIdHeaderName, new [] { traceId } },
-                { TraceProvider.SpanIdHeaderName, new [] { spanId } },
-                { TraceProvider.ParentSpanIdHeaderName, new [] { parentSpanId } },
-                { TraceProvider.SampledHeaderName, new [] { isSampled.ToString() } }
-            });
-            var environment = new Dictionary<string, object>();
+            var context = GenerateContext(
+                traceId,
+                spanId,
+                parentSpanId,
+                isSampled.ToString());
 
-            request.Stub(x => x.Headers).Return(headers);
-            context.Stub(x => x.Request).Return(request);
-            context.Stub(x => x.Environment).Return(environment);
+            // Act
+            var sut = new TraceProvider(new ZipkinConfig(), context);
+
+            // Assert
+            Assert.AreEqual(traceId, sut.TraceId);
+            Assert.AreEqual(spanId, sut.SpanId);
+            Assert.AreEqual(parentSpanId, sut.ParentSpanId);
+            Assert.AreEqual(isSampled, sut.IsSampled);
+        }
+
+        [TestMethod]
+        public void Constructor_AcceptingHeadersWithLessThan16HexCharacters()
+        {
+            // Arrange
+            var fixture = new Fixture();
+            var traceId = Convert.ToString(fixture.Create<long>(), 16).Substring(1);
+            var spanId = Convert.ToString(fixture.Create<long>(), 16);
+            var parentSpanId = Convert.ToString(fixture.Create<long>(), 16);
+            var isSampled = fixture.Create<bool>();
+
+            var context = GenerateContext(
+                traceId,
+                spanId,
+                parentSpanId,
+                isSampled.ToString());
+
+            // Act
+            var sut = new TraceProvider(new ZipkinConfig(), context);
+
+            // Assert
+            Assert.AreEqual(traceId, sut.TraceId);
+            Assert.AreEqual(spanId, sut.SpanId);
+            Assert.AreEqual(parentSpanId, sut.ParentSpanId);
+            Assert.AreEqual(isSampled, sut.IsSampled);
+        }
+
+        [TestMethod]
+        public void Constructor_AcceptingHeadersWith128BitTraceId()
+        {
+            // Arrange
+            var fixture = new Fixture();
+            var traceId = Guid.NewGuid().ToString("N");
+            var spanId = Convert.ToString(fixture.Create<long>(), 16);
+            var parentSpanId = Convert.ToString(fixture.Create<long>(), 16);
+            var isSampled = fixture.Create<bool>();
+
+            var context = GenerateContext(
+                traceId,
+                spanId,
+                parentSpanId,
+                isSampled.ToString());
 
             // Act
             var sut = new TraceProvider(new ZipkinConfig(), context);
@@ -58,7 +153,7 @@ public void ConstructorWithContextHavingAllIdValues()
         }
 
         [TestMethod]
-        public void ConstructorWithContextHavingIdValuesExceptIsSampled()
+        public void Constructor_AcceptingHeadersWithOutIsSampled()
         {
             // Arrange
             var fixture = new Fixture();
@@ -72,7 +167,7 @@ public void ConstructorWithContextHavingIdValuesExceptIsSampled()
             {
                 { TraceProvider.TraceIdHeaderName, new [] { traceId } },
                 { TraceProvider.SpanIdHeaderName, new [] { spanId } },
-                { TraceProvider.ParentSpanIdHeaderName, new [] { parentSpanId } },
+                { TraceProvider.ParentSpanIdHeaderName, new [] { parentSpanId } }
             });
             var environment = new Dictionary<string, object>();
 
@@ -95,29 +190,20 @@ public void ConstructorWithContextHavingIdValuesExceptIsSampled()
         }
 
         [TestMethod]
-        public void ConstructorWithContextHavingInvalidIdValues()
+        public void Constructor_AcceptingHeadersWithInvalidIdValues()
         {
             // Arrange
             var fixture = new Fixture();
-            var traceId = fixture.Create<string>();
+            var traceId = fixture.Create<Guid>().ToString("N").Substring(1);
             var spanId = fixture.Create<string>();
-            var parentSpanId = fixture.Create<string>();
+            var parentSpanId = fixture.Create<string>(); 
             var isSampled = fixture.Create<string>();
 
-            var context = MockRepository.GenerateStub<IOwinContext>();
-            var request = MockRepository.GenerateStub<IOwinRequest>();
-            var headers = new HeaderDictionary(new Dictionary<string, string[]>
-            {
-                { TraceProvider.TraceIdHeaderName, new [] { traceId } },
-                { TraceProvider.SpanIdHeaderName, new [] { spanId } },
-                { TraceProvider.ParentSpanIdHeaderName, new [] { parentSpanId } },
-                { TraceProvider.SampledHeaderName, new [] { isSampled } }
-            });
-            var environment = new Dictionary<string, object>();
-
-            request.Stub(x => x.Headers).Return(headers);
-            context.Stub(x => x.Request).Return(request);
-            context.Stub(x => x.Environment).Return(environment);
+            var context = GenerateContext(
+                traceId,
+                spanId,
+                parentSpanId,
+                isSampled);
 
             var expectedIsSampled = fixture.Create<bool>();
             var sampleFilter = MockRepository.GenerateStub<IZipkinConfig>();
@@ -128,56 +214,27 @@ public void ConstructorWithContextHavingInvalidIdValues()
 
             // Assert
             Assert.AreNotEqual(traceId, sut.TraceId);
-            Assert.AreEqual(sut.TraceId, sut.SpanId);
+            Assert.AreNotEqual(spanId, sut.SpanId);
             Assert.AreEqual(string.Empty, sut.ParentSpanId);
             Assert.AreEqual(expectedIsSampled, sut.IsSampled);
         }
-
-        [TestMethod]
-        public void ConstructorWithHavingTraceProviderInContext()
-        {
-            // Arrange
-            var context = MockRepository.GenerateStub<IOwinContext>();
-            var providerInContext = MockRepository.GenerateStub<ITraceProvider>();
-            var environment = new Dictionary<string, object>
-            {
-                { "Medidata.ZipkinTracer.Core.TraceProvider", providerInContext }
-            };
-            context.Stub(x => x.Environment).Return(environment);
-
-            // Act
-            var sut = new TraceProvider(new ZipkinConfig(), context);
-
-            // Assert
-            Assert.AreEqual(providerInContext.TraceId, sut.TraceId);
-            Assert.AreEqual(providerInContext.SpanId, sut.SpanId);
-            Assert.AreEqual(providerInContext.ParentSpanId, sut.ParentSpanId);
-            Assert.AreEqual(providerInContext.IsSampled, sut.IsSampled);
-        }
-
+        
         [TestMethod]
         [ExpectedException(typeof(ArgumentException))]
-        public void ConstructorWithContextHavingSameSpanAndParentSpan()
+        public void Constructor_AcceptingHeadersWithSpanAndParentSpan()
         {
             // Arrange
             var fixture = new Fixture();
             var traceId = Convert.ToString(fixture.Create<long>(), 16);
             var spanId = Convert.ToString(fixture.Create<long>(), 16);
             var parentSpanId = spanId;
+            var isSampled = fixture.Create<bool>();
 
-            var context = MockRepository.GenerateStub<IOwinContext>();
-            var request = MockRepository.GenerateStub<IOwinRequest>();
-            var headers = new HeaderDictionary(new Dictionary<string, string[]>
-            {
-                { TraceProvider.TraceIdHeaderName, new [] { traceId } },
-                { TraceProvider.SpanIdHeaderName, new [] { spanId } },
-                { TraceProvider.ParentSpanIdHeaderName, new [] { parentSpanId } }
-            });
-            var environment = new Dictionary<string, object>();
-
-            request.Stub(x => x.Headers).Return(headers);
-            context.Stub(x => x.Request).Return(request);
-            context.Stub(x => x.Environment).Return(environment);
+            var context = GenerateContext(
+                traceId,
+                spanId,
+                parentSpanId,
+                isSampled.ToString());
 
             // Act
             new TraceProvider(new ZipkinConfig(), context);
@@ -193,6 +250,26 @@ public void GetNext()
             var parentSpanId = Convert.ToString(fixture.Create<long>(), 16);
             var isSampled = fixture.Create<bool>();
 
+            var context = GenerateContext(
+                traceId,
+                spanId,
+                parentSpanId,
+                isSampled.ToString());
+
+            var sut = new TraceProvider(new ZipkinConfig(), context);
+
+            // Act
+            var nextTraceProvider = sut.GetNext();
+
+            // Assert
+            Assert.AreEqual(sut.TraceId, nextTraceProvider.TraceId);
+            Assert.IsTrue(Regex.IsMatch(nextTraceProvider.SpanId, regex64BitPattern));
+            Assert.AreEqual(sut.SpanId, nextTraceProvider.ParentSpanId);
+            Assert.AreEqual(sut.IsSampled, nextTraceProvider.IsSampled);
+        }
+        
+        private IOwinContext GenerateContext(string traceId, string spanId, string parentSpanId, string isSampled)
+        {
             var context = MockRepository.GenerateStub<IOwinContext>();
             var request = MockRepository.GenerateStub<IOwinRequest>();
             var headers = new HeaderDictionary(new Dictionary<string, string[]>
@@ -200,7 +277,7 @@ public void GetNext()
                 { TraceProvider.TraceIdHeaderName, new [] { traceId } },
                 { TraceProvider.SpanIdHeaderName, new [] { spanId } },
                 { TraceProvider.ParentSpanIdHeaderName, new [] { parentSpanId } },
-                { TraceProvider.SampledHeaderName, new [] { isSampled.ToString() } }
+                { TraceProvider.SampledHeaderName, new [] { isSampled } }
             });
             var environment = new Dictionary<string, object>();
 
@@ -208,15 +285,7 @@ public void GetNext()
             context.Stub(x => x.Request).Return(request);
             context.Stub(x => x.Environment).Return(environment);
 
-            var sut = new TraceProvider(new ZipkinConfig(), context);
-
-            // Act
-            var nextTraceProvider = sut.GetNext();
-
-            // Assert
-            Assert.AreEqual(sut.TraceId, nextTraceProvider.TraceId);
-            Assert.AreEqual(sut.SpanId, nextTraceProvider.ParentSpanId);
-            Assert.AreEqual(sut.IsSampled, nextTraceProvider.IsSampled);
+            return context;
         }
     }
 }
diff --git a/tests/Medidata.ZipkinTracer.Core.Test/ZipkinConfigTests.cs b/tests/Medidata.ZipkinTracer.Core.Test/ZipkinConfigTests.cs
index f937a9e..bf07dcf 100644
--- a/tests/Medidata.ZipkinTracer.Core.Test/ZipkinConfigTests.cs
+++ b/tests/Medidata.ZipkinTracer.Core.Test/ZipkinConfigTests.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Ploeh.AutoFixture;
+using Rhino.Mocks;
+using Microsoft.Owin;
 
 namespace Medidata.ZipkinTracer.Core.Test
 {
@@ -70,5 +72,196 @@ public void ValidateWithNullNotToBeDisplayedDomainList()
             _sut.NotToBeDisplayedDomainList = null;
             _sut.Validate();
         }
+
+        [TestMethod]
+        public void ShouldBeSampled_NullContext()
+        {
+            // Arrange
+            var fixture = new Fixture();
+
+            // Act
+            var result = _sut.ShouldBeSampled(null, "true");
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void ShouldBeSampled_NullSampledString()
+        {
+            // Arrange
+            var fixture = new Fixture();
+
+            var context = MockRepository.GenerateStub<IOwinContext>();
+            var request = MockRepository.GenerateStub<IOwinRequest>();
+            request.Path = new PathString("/samplePath");
+            context.Stub(x => x.Request).Return(request);
+
+            // Act
+            var result = _sut.ShouldBeSampled(context, null);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void ShouldBeSampled_WhiteSpaceSampledString()
+        {
+            // Arrange
+            var fixture = new Fixture();
+
+            var context = MockRepository.GenerateStub<IOwinContext>();
+            var request = MockRepository.GenerateStub<IOwinRequest>();
+            request.Path = new PathString("/samplePath");
+            context.Stub(x => x.Request).Return(request);
+
+            // Act
+            var result = _sut.ShouldBeSampled(context, string.Empty);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void ShouldBeSampled_InvalidSampledString()
+        {
+            // Arrange
+            var fixture = new Fixture();
+
+            var context = MockRepository.GenerateStub<IOwinContext>();
+            var request = MockRepository.GenerateStub<IOwinRequest>();
+            request.Path = new PathString("/samplePath");
+            context.Stub(x => x.Request).Return(request);
+
+            // Act
+            var result = _sut.ShouldBeSampled(context, "weirdValue");
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void ShouldBeSampled_PathNotInBlacktListSampleRate1_SampledStringTrue()
+        {
+            // Arrange
+            var fixture = new Fixture();
+
+            _sut.SampleRate = 1;
+
+            var context = MockRepository.GenerateStub<IOwinContext>();
+            var request = MockRepository.GenerateStub<IOwinRequest>();
+            request.Path = new PathString("/samplePath");
+            context.Stub(x => x.Request).Return(request);
+
+            // Act
+            var result =_sut.ShouldBeSampled(context, "true");
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        // TODO: Prepared for supporting 1/0 for sampled header
+        //[TestMethod]
+        //public void ShouldBeSampled_PathNotInBlacktListSampleRate1_SampledString1()
+        //{
+        //    // Arrange
+        //    var fixture = new Fixture();
+
+        //    _sut.SampleRate = 1;
+
+        //    var context = MockRepository.GenerateStub<IOwinContext>();
+        //    var request = MockRepository.GenerateStub<IOwinRequest>();
+        //    request.Path = new PathString("/samplePath");
+        //    context.Stub(x => x.Request).Return(request);
+
+        //    // Act
+        //    var result = _sut.ShouldBeSampled(context, "1");
+
+        //    // Assert
+        //    Assert.IsTrue(result);
+        //}
+
+        [TestMethod]
+        public void ShouldBeSampled_PathNotInBlacktListSampleRate1_SampledStringFalse()
+        {
+            // Arrange
+            var fixture = new Fixture();
+
+            _sut.SampleRate = 1;
+
+            var context = MockRepository.GenerateStub<IOwinContext>();
+            var request = MockRepository.GenerateStub<IOwinRequest>();
+            request.Path = new PathString("/samplePath");
+            context.Stub(x => x.Request).Return(request);
+
+            // Act
+            var result = _sut.ShouldBeSampled(context, "false");
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        // TODO: Prepared for supporting 1/0 for sampled header
+        //[TestMethod]
+        //public void ShouldBeSampled_PathNotInBlacktListSampleRate1_SampledString0()
+        //{
+        //    // Arrange
+        //    var fixture = new Fixture();
+
+        //    _sut.SampleRate = 1;
+
+        //    var context = MockRepository.GenerateStub<IOwinContext>();
+        //    var request = MockRepository.GenerateStub<IOwinRequest>();
+        //    request.Path = new PathString("/samplePath");
+        //    context.Stub(x => x.Request).Return(request);
+
+        //    // Act
+        //    var result = _sut.ShouldBeSampled(context, "0");
+
+        //    // Assert
+        //    Assert.IsFalse(result);
+        //}
+
+        [TestMethod]
+        public void ShouldBeSampled_PathNotInBlacktListSampleRate0()
+        {
+            // Arrange
+            var fixture = new Fixture();
+
+            _sut.SampleRate = 0;
+
+            var context = MockRepository.GenerateStub<IOwinContext>();
+            var request = MockRepository.GenerateStub<IOwinRequest>();
+            request.Path = new PathString("/samplePath");
+            context.Stub(x => x.Request).Return(request);
+
+            // Act
+            var result = _sut.ShouldBeSampled(context, null);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+
+        [TestMethod]
+        public void ShouldBeSampled_PathInBlacktList()
+        {
+            // Arrange
+            var fixture = new Fixture();
+
+            _sut.SampleRate = 0;
+            var path = "/samplePath";
+            _sut.NotToBeDisplayedDomainList.Add(path);
+
+            var context = MockRepository.GenerateStub<IOwinContext>();
+            var request = MockRepository.GenerateStub<IOwinRequest>();
+            request.Path = new PathString(path);
+            context.Stub(x => x.Request).Return(request);
+
+            // Act
+            var result = _sut.ShouldBeSampled(context, null);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
     }
 }
\ No newline at end of file
diff --git a/tests/Medidata.ZipkinTracer.Core.Test/packages.config b/tests/Medidata.ZipkinTracer.Core.Test/packages.config
index cfa0197..65ba0bd 100644
--- a/tests/Medidata.ZipkinTracer.Core.Test/packages.config
+++ b/tests/Medidata.ZipkinTracer.Core.Test/packages.config
@@ -1,9 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="AutoFixture" version="3.43.1" targetFramework="net45" />
-  <package id="AutoFixture.AutoRhinoMocks" version="3.43.1" targetFramework="net45" />
+  <package id="AutoFixture" version="3.50.2" targetFramework="net45" />
+  <package id="AutoFixture.AutoRhinoMocks" version="3.50.2" targetFramework="net45" />
+  <package id="Microsoft.Net.Compilers" version="1.3.2" targetFramework="net45" developmentDependency="true" />
   <package id="Microsoft.Owin" version="3.0.1" targetFramework="net45" />
-  <package id="Newtonsoft.Json" version="8.0.3" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="9.0.1" targetFramework="net45" />
   <package id="Owin" version="1.0" targetFramework="net45" />
   <package id="RhinoMocks" version="3.6.1" targetFramework="net45" />
 </packages>
\ No newline at end of file