{
    "api_version": "1",
    "kind": "dse_post",
    "self": "https://update.dsesecurity.com/api/v1/posts/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/",
    "item": {
        "id": "https://update.dsesecurity.com/updates/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/",
        "slug": "dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations",
        "url": "https://update.dsesecurity.com/updates/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/",
        "alternate_urls": {
            "markdown": "https://update.dsesecurity.com/updates/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations.md",
            "json": "https://update.dsesecurity.com/api/v1/posts/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/"
        },
        "title": "Read Code Optimizations memory percentages against trace allocations",
        "summary": "What is the denominator of a Code Optimizations memory percentage?",
        "format": {
            "slug": "explainer",
            "name": "Explainer"
        },
        "priority": {
            "slug": "info",
            "name": "Information"
        },
        "featured": false,
        "image": {
            "theme": "managed-it",
            "label": "Managed IT operations",
            "alt": "A controlled technology lifecycle progressing from assessment to approved production.",
            "card_url": "https://update.dsesecurity.com/assets/editorial/managed-it-card.webp?v=1.8.20",
            "hero_url": "https://update.dsesecurity.com/assets/editorial/managed-it-hero.webp?v=1.8.20",
            "social_url": "https://update.dsesecurity.com/assets/editorial/managed-it-social-v2.jpg?v=1.8.20",
            "width": 2400,
            "height": 1350
        },
        "topics": [
            {
                "slug": "it",
                "name": "IT",
                "url": "https://update.dsesecurity.com/topic/it/"
            }
        ],
        "author": {
            "name": "DSE Security Editorial Team",
            "url": "https://update.dsesecurity.com/#editorial-team",
            "type": "Organization"
        },
        "publisher": {
            "name": "Detection Systems & Engineering",
            "url": "https://dsesecurity.com/"
        },
        "published_at": "2026-09-10T00:29:55+00:00",
        "modified_at": "2026-09-10T00:52:38+00:00",
        "reviewed_on": "2026-09-09",
        "reading_minutes": 2,
        "word_count": 251,
        "potentially_affected": "Application Insights Code Optimizations memory findings viewed for an individual resource.",
        "dse_recommendation": "Describe a memory finding as its share of allocations in the trace, and retain allocation bytes and type details beside that percentage.",
        "primary_source": {
            "name": "Access and Interpret Code Optimizations Results - Azure Monitor | Microsoft Learn",
            "url": "https://learn.microsoft.com/en-us/azure/azure-monitor/optimization-insights/view-code-optimizations",
            "published_on": null,
            "authority": "Microsoft Learn"
        },
        "publishing_principles": "https://update.dsesecurity.com/updates/dse-updates-editorial-methodology/",
        "usage_info": "https://update.dsesecurity.com/usage/",
        "copyright_notice": "Copyright © 2026 Detection Systems & Engineering. All rights reserved.",
        "content_html": "<h2>Source facts</h2>\n<p>Code Optimizations expresses a memory finding as a percentage of all allocations in the trace. It also provides actual allocation sizes in bytes and a breakdown of allocated types within the call. The individual-resource view can filter results by time, role and insight type, and an insight includes its call stack. <a href=\"https://learn.microsoft.com/en-us/azure/azure-monitor/optimization-insights/view-code-optimizations\" target=\"_blank\" rel=\"noopener noreferrer\">Microsoft Learn</a>.</p>\n<h2>Applicability</h2>\n<p>Use this interpretation for a Code Optimizations memory insight, not as a replacement for a separately measured host-memory or process-residency value. Keep the trace and selected workload context attached to the number.</p>\n<h2>DSE recommendation</h2>\n<p>Describe a memory finding as its share of allocations in the trace, and retain allocation bytes and type details beside that percentage. Ask the application owner to identify the relevant call path and whether the observed workload represents the problem being investigated. Do not translate an allocation share directly into a claim that the method occupies that percentage of the machine&#8217;s RAM. Separate the diagnostic lead from any proposed code change.</p>\n<h2>Verification</h2>\n<p>Open the insight with an explicit time and role selection and inspect its allocation details and call stack. Compare like-for-like observations when evaluating a proposed change, recording any workload or capture differences. Check that the resulting ticket or report names the allocation denominator rather than using an ambiguous memory percentage. Retain the underlying observations; a lower share alone should not be reported as a measured reduction in resident memory or as proof that the application&#8217;s problem was resolved.</p>\n<h2>Official references</h2>\n<p><a href=\"https://learn.microsoft.com/en-us/azure/azure-monitor/optimization-insights/view-code-optimizations\" target=\"_blank\" rel=\"noopener noreferrer\">Microsoft Learn: Interpret Code Optimizations results</a>. Source reviewed September 9, 2026.</p>",
        "content_text": "Source facts\nCode Optimizations expresses a memory finding as a percentage of all allocations in the trace. It also provides actual allocation sizes in bytes and a breakdown of allocated types within the call. The individual-resource view can filter results by time, role and insight type, and an insight includes its call stack. Microsoft Learn.\nApplicability\nUse this interpretation for a Code Optimizations memory insight, not as a replacement for a separately measured host-memory or process-residency value. Keep the trace and selected workload context attached to the number.\nDSE recommendation\nDescribe a memory finding as its share of allocations in the trace, and retain allocation bytes and type details beside that percentage. Ask the application owner to identify the relevant call path and whether the observed workload represents the problem being investigated. Do not translate an allocation share directly into a claim that the method occupies that percentage of the machine’s RAM. Separate the diagnostic lead from any proposed code change.\nVerification\nOpen the insight with an explicit time and role selection and inspect its allocation details and call stack. Compare like-for-like observations when evaluating a proposed change, recording any workload or capture differences. Check that the resulting ticket or report names the allocation denominator rather than using an ambiguous memory percentage. Retain the underlying observations; a lower share alone should not be reported as a measured reduction in resident memory or as proof that the application’s problem was resolved.\nOfficial references\nMicrosoft Learn: Interpret Code Optimizations results. Source reviewed September 9, 2026.",
        "content_markdown": "## Source facts\n\nCode Optimizations expresses a memory finding as a percentage of all allocations in the trace. It also provides actual allocation sizes in bytes and a breakdown of allocated types within the call. The individual-resource view can filter results by time, role and insight type, and an insight includes its call stack. [Microsoft Learn](https://learn.microsoft.com/en-us/azure/azure-monitor/optimization-insights/view-code-optimizations).\n\n## Applicability\n\nUse this interpretation for a Code Optimizations memory insight, not as a replacement for a separately measured host-memory or process-residency value. Keep the trace and selected workload context attached to the number.\n\n## DSE recommendation\n\nDescribe a memory finding as its share of allocations in the trace, and retain allocation bytes and type details beside that percentage. Ask the application owner to identify the relevant call path and whether the observed workload represents the problem being investigated. Do not translate an allocation share directly into a claim that the method occupies that percentage of the machine’s RAM. Separate the diagnostic lead from any proposed code change.\n\n## Verification\n\nOpen the insight with an explicit time and role selection and inspect its allocation details and call stack. Compare like-for-like observations when evaluating a proposed change, recording any workload or capture differences. Check that the resulting ticket or report names the allocation denominator rather than using an ambiguous memory percentage. Retain the underlying observations; a lower share alone should not be reported as a measured reduction in resident memory or as proof that the application’s problem was resolved.\n\n## Official references\n\n[Microsoft Learn: Interpret Code Optimizations results](https://learn.microsoft.com/en-us/azure/azure-monitor/optimization-insights/view-code-optimizations). Source reviewed September 9, 2026."
    },
    "json_ld": {
        "@context": "https://schema.org",
        "@graph": [
            {
                "@type": "Organization",
                "@id": "https://dsesecurity.com/#organization",
                "name": "Detection Systems & Engineering",
                "alternateName": "DSE Security",
                "url": "https://dsesecurity.com/",
                "logo": {
                    "@type": "ImageObject",
                    "url": "https://update.dsesecurity.com/assets/dse-logo-20260812.png?v=1.8.20"
                }
            },
            {
                "@type": "Organization",
                "@id": "https://update.dsesecurity.com/#editorial-team",
                "name": "DSE Security Editorial Team",
                "url": "https://update.dsesecurity.com/",
                "parentOrganization": {
                    "@id": "https://dsesecurity.com/#organization"
                }
            },
            {
                "@type": "WebSite",
                "@id": "https://update.dsesecurity.com/#website",
                "name": "DSE Updates",
                "alternateName": "DSE Security Knowledge Hub",
                "url": "https://update.dsesecurity.com/",
                "inLanguage": "en-US",
                "publisher": {
                    "@id": "https://dsesecurity.com/#organization"
                },
                "potentialAction": {
                    "@type": "SearchAction",
                    "target": {
                        "@type": "EntryPoint",
                        "urlTemplate": "https://update.dsesecurity.com/?q={search_term_string}"
                    },
                    "query-input": "required name=search_term_string"
                }
            },
            {
                "@type": "WebPage",
                "@id": "https://update.dsesecurity.com/updates/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/",
                "url": "https://update.dsesecurity.com/updates/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/",
                "isPartOf": {
                    "@id": "https://update.dsesecurity.com/#website"
                },
                "lastReviewed": "2026-09-09"
            },
            {
                "@type": "BreadcrumbList",
                "@id": "https://update.dsesecurity.com/updates/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/#breadcrumbs",
                "itemListElement": [
                    {
                        "@type": "ListItem",
                        "position": 1,
                        "name": "DSE Updates",
                        "item": "https://update.dsesecurity.com/"
                    },
                    {
                        "@type": "ListItem",
                        "position": 2,
                        "name": "Read Code Optimizations memory percentages against trace allocations",
                        "item": "https://update.dsesecurity.com/updates/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/"
                    }
                ]
            },
            {
                "@type": [
                    "Article",
                    "TechArticle"
                ],
                "@id": "https://update.dsesecurity.com/updates/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/#article",
                "identifier": "https://update.dsesecurity.com/updates/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/",
                "url": "https://update.dsesecurity.com/updates/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/",
                "headline": "Read Code Optimizations memory percentages against trace allocations",
                "description": "What is the denominator of a Code Optimizations memory percentage?",
                "abstract": "What is the denominator of a Code Optimizations memory percentage?",
                "articleBody": "Source facts\nCode Optimizations expresses a memory finding as a percentage of all allocations in the trace. It also provides actual allocation sizes in bytes and a breakdown of allocated types within the call. The individual-resource view can filter results by time, role and insight type, and an insight includes its call stack. Microsoft Learn.\nApplicability\nUse this interpretation for a Code Optimizations memory insight, not as a replacement for a separately measured host-memory or process-residency value. Keep the trace and selected workload context attached to the number.\nDSE recommendation\nDescribe a memory finding as its share of allocations in the trace, and retain allocation bytes and type details beside that percentage. Ask the application owner to identify the relevant call path and whether the observed workload represents the problem being investigated. Do not translate an allocation share directly into a claim that the method occupies that percentage of the machine’s RAM. Separate the diagnostic lead from any proposed code change.\nVerification\nOpen the insight with an explicit time and role selection and inspect its allocation details and call stack. Compare like-for-like observations when evaluating a proposed change, recording any workload or capture differences. Check that the resulting ticket or report names the allocation denominator rather than using an ambiguous memory percentage. Retain the underlying observations; a lower share alone should not be reported as a measured reduction in resident memory or as proof that the application’s problem was resolved.\nOfficial references\nMicrosoft Learn: Interpret Code Optimizations results. Source reviewed September 9, 2026.",
                "datePublished": "2026-09-10T00:29:55+00:00",
                "dateModified": "2026-09-10T00:52:38+00:00",
                "mainEntityOfPage": {
                    "@id": "https://update.dsesecurity.com/updates/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/"
                },
                "inLanguage": "en-US",
                "isAccessibleForFree": true,
                "author": {
                    "@type": "Organization",
                    "name": "DSE Security Editorial Team",
                    "url": "https://update.dsesecurity.com/#editorial-team"
                },
                "publisher": {
                    "@id": "https://dsesecurity.com/#organization"
                },
                "image": {
                    "@type": "ImageObject",
                    "@id": "https://update.dsesecurity.com/updates/dse-20260909-121-read-code-optimizations-memory-percentages-against-trace-allocations/#primaryimage",
                    "url": "https://update.dsesecurity.com/assets/editorial/managed-it-social-v2.jpg?v=1.8.20",
                    "contentUrl": "https://update.dsesecurity.com/assets/editorial/managed-it-social-v2.jpg?v=1.8.20",
                    "width": 1200,
                    "height": 630,
                    "caption": "Read Code Optimizations memory percentages against trace allocations"
                },
                "articleSection": [
                    "IT"
                ],
                "keywords": [
                    "IT",
                    "Explainer",
                    "Information priority"
                ],
                "genre": "Explainer",
                "about": [
                    {
                        "@type": "Thing",
                        "name": "IT",
                        "url": "https://update.dsesecurity.com/topic/it/"
                    }
                ],
                "wordCount": 251,
                "timeRequired": "PT2M",
                "publishingPrinciples": "https://update.dsesecurity.com/updates/dse-updates-editorial-methodology/",
                "usageInfo": "https://update.dsesecurity.com/usage/",
                "copyrightHolder": {
                    "@id": "https://dsesecurity.com/#organization"
                },
                "copyrightNotice": "Copyright © 2026 Detection Systems & Engineering. All rights reserved.",
                "citation": {
                    "@type": "CreativeWork",
                    "name": "Access and Interpret Code Optimizations Results - Azure Monitor | Microsoft Learn",
                    "url": "https://learn.microsoft.com/en-us/azure/azure-monitor/optimization-insights/view-code-optimizations"
                }
            }
        ]
    }
}