public static IEnumerable <IClrObjMappingModel> ExtractFromHeap(this IModelMapperFactory factory, IObjectEnumerationFacade objectEnumeration, ClrRuntime runtime)
{
foreach (var clrObject in objectEnumeration.ExtractFromRuntime(runtime))
{
yield return(factory.BuildModel(clrObject));
}
}
/// <summary>
/// Provides text statistics for pending <see cref="HttpContext"/> that wait for Redis commands.
/// <para>Scans thread stacks for <see cref="HttpContext"/> instances, and <see cref="string"/>s that contain 'redis.call' text inside.</para>
/// </summary>
/// <param name="connection"></param>
/// <param name="connectionFactory"></param>
/// <param name="threadFilter"></param>
/// <param name="threadStackObjectsFilter"></param>
/// <param name="factory"></param>
/// <returns></returns>
public virtual StringBuilder ExtractRedisPendingCommandsForRequests(IMemoryDumpConnectionPath connection, IClrRuntimeFactory connectionFactory = null,
IModelMapperFactory factory = null)
{
var runtime = (connectionFactory ?? MDClrRuntimeFactory.Instance).BuildClrRuntime(connection);
return(ExtractRedisPendingCommandsForRequests(runtime, factory ?? ModelMapperManager.NewMapperFactory));
}
public ConfigurationFactory(
IModelMapperFactory modelMapperFactory,
IDictionary <string, string> properties
)
{
_modelMapperFactory = modelMapperFactory;
_properties = properties;
}
public static IEnumerable <IClrObjMappingModel> ExtractFromHeap(this IModelMapperFactory factory, IFilteredObjectsProvider clrObjectFilter, string pathToDumpFile, string pathToMsCord = null)
{
if (string.IsNullOrEmpty(pathToMsCord))
{
MDClrRuntimeFactory.TryGetMscordacPath(pathToDumpFile, out pathToMsCord);
}
var connectionDetails = new MDFileConnection(pathToDumpFile, pathToMsCord);
return(ExtractFromHeap(factory, clrObjectFilter, connectionDetails));
}
protected virtual void ExtractCommandOrContext(ClrObject clrObj, IModelMapperFactory factory, ref string command, ref HttpContextMappingModel httpContext)
{
if (clrObj.Type?.IsString == true)
{
command = clrObj.GetStringSafeFromSelf();
}
else
{
httpContext = factory.BuildModel(clrObj) as HttpContextMappingModel;
}
}
public static IEnumerable <IClrObjMappingModel> ExtractFromHeapByType(this IModelMapperFactory factory, string typeName, IMemoryDumpConnectionPath connectionDetails)
{
var clrObjectFilter = BuildFilterByTypeName(typeName);
return(ExtractFromHeap(factory, clrObjectFilter, connectionDetails));
}
public virtual void ExtractContextAndRedisCommand(ClrThread thread, ThreadStackEnumerator threadStackObjectEnumerator, IModelMapperFactory factory, IDictionary <string, List <HttpContextMappingModel> > contextsByRedisCommands)
{
string command = null;
HttpContextMappingModel httpContext = null;
foreach (var clrObj in threadStackObjectEnumerator.Enumerate(thread))
{
ExtractCommandOrContext(clrObj, factory, ref command, ref httpContext);
// already extracted both from the thread stack.
if (!string.IsNullOrEmpty(command) && (httpContext != null))
{
break;
}
}
List <HttpContextMappingModel> httpContextsForGivenRedisCommand = null;
if (!string.IsNullOrEmpty(command))
{
if (!contextsByRedisCommands.ContainsKey(command))
{
httpContextsForGivenRedisCommand = new List <HttpContextMappingModel>();
contextsByRedisCommands.Add(command, httpContextsForGivenRedisCommand);
}
else
{
httpContextsForGivenRedisCommand = contextsByRedisCommands[command];
}
}
if (httpContext?.HasURL == true && httpContext?.Request != null)
{
if (httpContextsForGivenRedisCommand != null)
{
httpContextsForGivenRedisCommand.Add(httpContext);
}
else
{
if (!contextsByRedisCommands.ContainsKey("NoCommand"))
{
contextsByRedisCommands.Add("NoCommand", new List <HttpContextMappingModel>());
}
var noCommand = contextsByRedisCommands["NoCommand"];
noCommand.Add(httpContext);
}
}
}
public SitecoreCacheEnumerator(IModelMapperFactory modelMapper) : base("Sitecore.Caching.CacheManager", "Instance")
{
this.modelMapper = modelMapper;
}
public static IEnumerable <IClrObjMappingModel> ExtractFromHeap(this IModelMapperFactory factory, IFilteredObjectsProvider clrObjectFilter, ClrRuntime runtime)
{
return(ExtractFromHeap(factory, new HeapBasedFacadeObjectEnumerator(clrObjectFilter), runtime));
}
public static IEnumerable <IClrObjMappingModel> ExtractFromHeap(this IModelMapperFactory factory, IFilteredObjectsProvider clrObjectFilter, IMemoryDumpConnectionPath connection)
{
var runtime = MDClrRuntimeFactory.Instance.BuildClrRuntime(connection);
return(ExtractFromHeap(factory, clrObjectFilter, runtime));
}
public virtual StringBuilder ExtractRedisPendingCommandsForRequests(ClrRuntime runtime, IModelMapperFactory clrObjectToModelFactory)
{
var knownObjects = new HashSet <ulong>();
var threadStackObjectEnumerator = new ThreadStackEnumerator(
includePossiblyDead: true,
filter: ThreadStackObjectFilter);
List <string> commands = new List <string>();
int totalContexts = 0;
IDictionary <string, List <HttpContextMappingModel> > httpContextsMappedByRedisCommand = new Dictionary <string, List <HttpContextMappingModel> >();
foreach (var contextThread in ThreadFilter.ExtactAliveUserThreads(runtime))
{
ExtractContextAndRedisCommand(contextThread, threadStackObjectEnumerator, clrObjectToModelFactory, httpContextsMappedByRedisCommand);
}
var differentRedisCommands = httpContextsMappedByRedisCommand.OrderByDescending(grouping => grouping.Value.Count);
var aspNetIDs = (from requestGroup in httpContextsMappedByRedisCommand
let httpContexts = requestGroup.Value
from httpContext in httpContexts
let requestInfo = new { httpContext, httpContext?.Request?.AspNetSessionId }
group requestInfo by requestInfo.AspNetSessionId into sameSessions
select sameSessions).OrderByDescending(t => t.Count()).ToArray();
var sb = new StringBuilder();
sb.AppendLine($"Different Commands found: {differentRedisCommands.Count()}");
totalContexts = httpContextsMappedByRedisCommand.Sum(elem => elem.Value.Count);
sb.AppendLine($"Total requests {totalContexts} VS unique asp.net sessions {aspNetIDs.Length}");
foreach (var cmd in differentRedisCommands)
{
sb.AppendLine($"Hits: {cmd.Value.Count}");
sb.AppendLine();
sb.AppendLine(cmd.Key);
foreach (var context in cmd.Value.OrderByDescending(request => request.ExecutionDuration))
{
sb.AppendLine(FormatLine(context));
}
sb.AppendLine("**************");
}
foreach (var session in aspNetIDs)
{
sb.AppendLine($"Session: {session.Key}:");
foreach (var request in session)
{
sb.AppendLine($"{request.httpContext.URL} executed for {request.httpContext.ExecutionDuration.TotalSeconds:F2} sec.");
}
sb.AppendLine("**************");
sb.AppendLine();
}
return(sb);
}
public static IEnumerable <T> EnumerateObjectsFromHeap <T>(this IFilteredObjectsProvider filteredObjectProvider, IMemoryDumpConnectionPath connection, IModelMapperFactory factory, IClrRuntimeFactory runtimeFactory = null) where T : class, IClrObjMappingModel
{
runtimeFactory = runtimeFactory ?? MDClrRuntimeFactory.Instance;
var runtime = MDClrRuntimeFactory.Instance.BuildClrRuntime(connection);
var heapObjects = HeapBasedClrObjectEnumerator.Instance;
var stream = filteredObjectProvider.ExtractFromRuntime(runtime, heapObjects);
foreach (var matched in stream)
{
yield return(factory.BuildOfType <T>(matched));
}
}
public static IEnumerable <TMappingType> ExtractFromHeap <TMappingType>(this IModelMapperFactory factory, IMemoryDumpConnectionPath connectionDetails) where TMappingType : IClrObjMappingModel
{
var typeName = ModelMappingAttribute.GetTypeToMapOn(typeof(TMappingType), assert: true);
return(ExtractFromHeapByType(factory, typeName, connectionDetails).OfType <TMappingType>());
}
public static IEnumerable <IClrObjMappingModel> ExtractFromHeapByType(this IModelMapperFactory factory, string typeName, string pathToDumpFile, string pathToMsCord = null)
{
var clrObjectFilter = BuildFilterByTypeName(typeName);
return(ExtractFromHeap(factory, clrObjectFilter, pathToDumpFile, pathToMsCord));
}
public static IEnumerable <IClrObjMappingModel> ExtractFromHeapByType(this IModelMapperFactory factory, Type type, string pathToDumpFile, string pathToMsCord = null)
{
return(ExtractFromHeapByType(factory, type.FullName, pathToDumpFile, pathToMsCord));
}
public virtual IOrderedEnumerable <ContactInfo> ExtractRequestsByContact(ClrRuntime runtime, IModelMapperFactory modelMapperFactory)
{
var httpContextStreamClrObject = ObjectFilter.ExtractFromRuntime(runtime, ObjectEnumerator);
var requestsGroupedByContactID = from clrObject in httpContextStreamClrObject
let context = modelMapperFactory.BuildModel(clrObject) as HttpContextMappingModel
where IsValid(context)
let request = context._request as HttpRequestMappingModel
where request != null
let cookies = request._cookies.Value as HashtableMappingModel
where cookies != null
where cookies.Elements.ContainsKey(TextConstants.CookieNames.SitecoreAnalyticsGlobal)
// where cookies.Elements.ContainsKey(TextConstants.CookieNames.AspNetSession)
let analyticsCookie = cookies[TextConstants.CookieNames.SitecoreAnalyticsGlobal] as HttpCookieModel
let sessionCookie = cookies[TextConstants.CookieNames.AspNetSession] as HttpCookieModel
where !string.IsNullOrEmpty(analyticsCookie.Value)
// where !string.IsNullOrEmpty(sessionCookie.Value)
let workerRequest = context._wr as IIS7WorkerRequestModel
where workerRequest != null
let metadata = new
{
context.URL,
TotalSeconds = Math.Round(context.ExecutionDuration.TotalSeconds, 2),
analyticsId = analyticsCookie.Value,
aspSession = sessionCookie?.Value ?? "[NoSession]",
context = context.HexAddress,
request = request.HexAddress
}
where metadata.TotalSeconds > 0
group metadata by metadata.request into uniqueRequests
let uniqueRequest = uniqueRequests.First()
group uniqueRequest by uniqueRequest.analyticsId into grouped
orderby grouped.Count() descending
let contactInfo = new ContactInfo
{
ContactId = grouped.Key,
Count = grouped.Count(),
DistinctAspNet = grouped.Select(g => g.aspSession).Distinct().Count(),
Requests = grouped.Select(requestInfo => new RequestInfo
{
URL = requestInfo.URL,
TotalSeconds = requestInfo.TotalSeconds,
aspSession = requestInfo.aspSession,
context = requestInfo.context,
request = requestInfo.request
}).OrderByDescending(g => g.TotalSeconds),
}
select contactInfo;
return(requestsGroupedByContactID.OrderByDescending(t => t.Count));
}
public PrintStringBuilders(int minimumTimeMetToPrint = 3, IClrRuntimeFactory runtimeFactory = null, IModelMapperFactory modelMapperFactory = null)
{
_minimumTimeMetToPrint = minimumTimeMetToPrint;
_runtimeFactory = runtimeFactory ?? MDClrRuntimeFactory.Instance;
_modelMapperFactory = modelMapperFactory;
}
public static T BuildOfType <T>(this IModelMapperFactory factory, [CanBeNullObject] ClrObject obj) where T : class, IClrObjMappingModel
{
return(factory.BuildModel(obj) as T);
}
public static IEnumerable <IClrObjMappingModel> ExtractFromHeapByTypeName(this IModelMapperFactory factory, string typeName, ClrRuntime runtime)
{
return(ExtractFromHeap(factory, new HeapBasedFacadeObjectEnumerator(typeName), runtime));
}
