From e2bfdc81aafb2464bb4f7188e842c4f02a854b01 Mon Sep 17 00:00:00 2001
From: Avishai Dotan <108017307+AvishaiDotan@users.noreply.github.com>
Date: Thu, 9 Jan 2025 08:47:21 +0200
Subject: [PATCH 1/5] continue with implementing configs

---
 samples/BenchmarkDotNet.Samples/IntroRPlot.cs | 39 +++++++++++++++++
 samples/BenchmarkDotNet.Samples/Program.cs    |  3 +-
 .../Exporters/RPlotExporterAttribute.cs       | 11 ++++-
 .../Configs/ConfigExtensions.cs               |  4 ++
 src/BenchmarkDotNet/Configs/DefaultConfig.cs  |  2 +-
 .../Configs/ImmutableConfig.cs                |  5 +++
 .../Configs/ImmutableConfigBuilder.cs         | 42 +++++++++++++++++-
 src/BenchmarkDotNet/Configs/ManualConfig.cs   | 23 +++++++++-
 .../Exporters/IIntegratedExports.cs           | 11 +++++
 .../Exporters/IntegratedExport.cs             | 36 ++++++++++++++++
 .../Exporters/RPlotExporter.cs                | 10 ++++-
 .../Running/BenchmarkConverter.cs             | 43 ++++++++++++++++++-
 .../Running/BenchmarkRunnerClean.cs           |  1 +
 13 files changed, 222 insertions(+), 8 deletions(-)
 create mode 100644 samples/BenchmarkDotNet.Samples/IntroRPlot.cs
 create mode 100644 src/BenchmarkDotNet/Exporters/IIntegratedExports.cs
 create mode 100644 src/BenchmarkDotNet/Exporters/IntegratedExport.cs

diff --git a/samples/BenchmarkDotNet.Samples/IntroRPlot.cs b/samples/BenchmarkDotNet.Samples/IntroRPlot.cs
new file mode 100644
index 0000000000..e72bde95ce
--- /dev/null
+++ b/samples/BenchmarkDotNet.Samples/IntroRPlot.cs
@@ -0,0 +1,39 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Exporters;
+
+
+namespace BenchmarkDotNet.Samples
+{
+    //[MemoryDiagnoser]
+    //[Config(typeof(Config))]
+    [RPlotExporter(IntegratedExportEnum.HtmlExporterWithRPlotExporter)]
+    public class IntroRPlot
+    {
+        [Benchmark]
+        public void Benchmark()
+        {
+            var result = Calculate();
+        }
+
+        private int Calculate()
+        {
+            int sum = 0;
+            for (int i = 0; i < 1000; i++)
+            {
+                sum += i;
+            }
+            return sum;
+        }
+    }
+
+    public class Config : ManualConfig
+    {
+        public Config()
+        {
+            //AddExporter(CsvMeasurementsExporter.Default);
+            //AddExporter(RPlotExporter.Default);
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/samples/BenchmarkDotNet.Samples/Program.cs b/samples/BenchmarkDotNet.Samples/Program.cs
index 71daa668ba..230d26f2f2 100644
--- a/samples/BenchmarkDotNet.Samples/Program.cs
+++ b/samples/BenchmarkDotNet.Samples/Program.cs
@@ -4,6 +4,7 @@ namespace BenchmarkDotNet.Samples
 {
     public class Program
     {
-        public static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
+        //public static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
+        public static void Main(string[] args) => BenchmarkRunner.Run<IntroRPlot>();
     }
 }
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs b/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs
index 4b4f6d9c39..e9bb97efde 100644
--- a/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs
+++ b/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs
@@ -1,10 +1,19 @@
 using BenchmarkDotNet.Exporters;
+using System;
+using System.Collections.Generic;
 
 namespace BenchmarkDotNet.Attributes
 {
     public class RPlotExporterAttribute : ExporterConfigBaseAttribute
     {
-        public RPlotExporterAttribute() : base(DefaultExporters.RPlot)
+        /// <param name="reportDependencies">
+        /// Determines whether Rplot exported images should be added to the HTML report (a.k.a HTML report).
+        /// False by default (rplotImages will not be displayed).
+        /// </param>
+        protected RPlotExporterAttribute()
+        {}
+
+        public RPlotExporterAttribute(params IntegratedExportEnum[] integratedExportEnums) : base(new RPlotExporter(integratedExportEnums))
         {
         }
     }
diff --git a/src/BenchmarkDotNet/Configs/ConfigExtensions.cs b/src/BenchmarkDotNet/Configs/ConfigExtensions.cs
index 5177227c2a..3d6730f0ac 100644
--- a/src/BenchmarkDotNet/Configs/ConfigExtensions.cs
+++ b/src/BenchmarkDotNet/Configs/ConfigExtensions.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.ComponentModel;
 using System.Globalization;
@@ -76,6 +77,9 @@ public static class ConfigExtensions
         [PublicAPI] public static ManualConfig WithUnionRule(this IConfig config, ConfigUnionRule unionRule) => config.With(m => m.WithUnionRule(unionRule));
         [PublicAPI] public static ManualConfig WithCultureInfo(this IConfig config, CultureInfo cultureInfo) => config.With(m => m.CultureInfo = cultureInfo);
 
+        [PublicAPI] public static ManualConfig WithSetExporters(this IConfig config, List<IExporter> exporters) => config.With(m => m.WithSetExporters(exporters));
+        [PublicAPI] public static ManualConfig WithSetIntegratedExporters(this IConfig config, List<IntegratedExport> exporters) => config.With(m => m.WithSetIntegratedExporters(exporters));
+
         /// <summary>
         /// determines if all auto-generated files should be kept or removed after running the benchmarks
         /// </summary>
diff --git a/src/BenchmarkDotNet/Configs/DefaultConfig.cs b/src/BenchmarkDotNet/Configs/DefaultConfig.cs
index b70333cc1d..e1cf0e3b8a 100644
--- a/src/BenchmarkDotNet/Configs/DefaultConfig.cs
+++ b/src/BenchmarkDotNet/Configs/DefaultConfig.cs
@@ -77,7 +77,7 @@ public IEnumerable<IValidator> GetValidators()
         public IOrderer Orderer => null;
         public ICategoryDiscoverer? CategoryDiscoverer => null;
 
-        public ConfigUnionRule UnionRule => ConfigUnionRule.Union;
+        public ConfigUnionRule UnionRule { get; set; } = ConfigUnionRule.Union;
 
         public CultureInfo CultureInfo => null;
 
diff --git a/src/BenchmarkDotNet/Configs/ImmutableConfig.cs b/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
index b6e03126fd..06ff27ee8e 100644
--- a/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
+++ b/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
@@ -24,6 +24,7 @@ public sealed class ImmutableConfig : IConfig
         // if something is an array here instead of hashset it means it must have a guaranteed order of elements
         private readonly ImmutableArray<IColumnProvider> columnProviders;
         private readonly ImmutableArray<IExporter> exporters;
+        private readonly ImmutableArray<IntegratedExport> integratedExports;
         private readonly ImmutableHashSet<ILogger> loggers;
         private readonly ImmutableHashSet<IDiagnoser> diagnosers;
         private readonly ImmutableHashSet<IAnalyser> analysers;
@@ -41,6 +42,7 @@ internal ImmutableConfig(
             ImmutableHashSet<HardwareCounter> uniqueHardwareCounters,
             ImmutableHashSet<IDiagnoser> uniqueDiagnosers,
             ImmutableArray<IExporter> uniqueExporters,
+            ImmutableArray<IntegratedExport> uniqueIntegratedExports,
             ImmutableHashSet<IAnalyser> uniqueAnalyzers,
             ImmutableHashSet<IValidator> uniqueValidators,
             ImmutableHashSet<IFilter> uniqueFilters,
@@ -63,6 +65,7 @@ internal ImmutableConfig(
             hardwareCounters = uniqueHardwareCounters;
             diagnosers = uniqueDiagnosers;
             exporters = uniqueExporters;
+            integratedExports = uniqueIntegratedExports;
             analysers = uniqueAnalyzers;
             validators = uniqueValidators;
             filters = uniqueFilters;
@@ -92,6 +95,8 @@ internal ImmutableConfig(
 
         public IEnumerable<IColumnProvider> GetColumnProviders() => columnProviders;
         public IEnumerable<IExporter> GetExporters() => exporters;
+
+        public IEnumerable<IntegratedExport> GetIntegratedExports() => integratedExports;
         public IEnumerable<ILogger> GetLoggers() => loggers;
         public IEnumerable<IDiagnoser> GetDiagnosers() => diagnosers;
         public IEnumerable<IAnalyser> GetAnalysers() => analysers;
diff --git a/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs b/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
index d7c0b5eb0f..cd7cb6611a 100644
--- a/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
+++ b/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
@@ -43,7 +43,10 @@ public static ImmutableConfig Create(IConfig source)
 
             var uniqueHardwareCounters = source.GetHardwareCounters().Where(counter => counter != HardwareCounter.NotSet).ToImmutableHashSet();
             var uniqueDiagnosers = GetDiagnosers(source.GetDiagnosers(), uniqueHardwareCounters);
-            var uniqueExporters = GetExporters(source.GetExporters(), uniqueDiagnosers, configAnalyse);
+            var allExporters = GetExporters(source.GetExporters(), uniqueDiagnosers, configAnalyse);
+
+            // Check for integrated exporters
+            var (uniqueExporters, integratedExports) = ProcessIntegratedConfiguration(allExporters);
             var uniqueAnalyzers = GetAnalysers(source.GetAnalysers(), uniqueDiagnosers);
 
             var uniqueValidators = GetValidators(source.GetValidators(), MandatoryValidators, source.Options);
@@ -61,6 +64,7 @@ public static ImmutableConfig Create(IConfig source)
                 uniqueHardwareCounters,
                 uniqueDiagnosers,
                 uniqueExporters,
+                integratedExports,
                 uniqueAnalyzers,
                 uniqueValidators,
                 uniqueFilters,
@@ -254,5 +258,41 @@ private class TypeComparer<TInterface> : IEqualityComparer<TInterface>
 
             public int GetHashCode(TInterface obj) => obj.GetType().GetHashCode();
         }
+
+        private static IReadOnlyCollection<IntegratedExportEnum> ExtractIntegrationExportEnums(IEnumerable<IExporter> exporters)
+        {
+            return exporters
+                    .OfType<IIntegratedExports>()
+                    .Where(export => export.IntegratedExportEnums.Any())
+                    .SelectMany(export => export.IntegratedExportEnums)
+                    .ToList();
+        }
+
+        private static (ImmutableArray<IExporter> UniqueExporters, ImmutableArray<IntegratedExport> IntegratedExports) ProcessIntegratedConfiguration(ImmutableArray<IExporter> allExporters)
+        {
+            var integratedExportEnums = ExtractIntegrationExportEnums(allExporters);
+            var integratedExports = integratedExportEnums.Select(exportEnum =>
+            {
+                var exporterTypesStr = IntegratedExportersMap.SplitEnumByWith(exportEnum);
+                return new IntegratedExport
+                {
+                    ExportEnum = exportEnum,
+                    Exporter = allExporters.FirstOrDefault(e => exporterTypesStr[0] == e.Name),
+                    WithExporter = allExporters.FirstOrDefault(e => exporterTypesStr[1] == e.Name),
+                    Dependencies = allExporters
+                                    .Where(exporter => exporter is IExporterDependencies)
+                                    .SelectMany(exporter => (exporter as IExporterDependencies).Dependencies)
+                                    .ToList()
+                };
+            }).ToList();
+
+            var distinctExporters = allExporters
+                .Where(exporter => !integratedExports
+                 .Any(integrated => integrated.Exporter?.Name == exporter.Name ||
+                                    integrated.WithExporter?.Name == exporter.Name || !integrated.Dependencies.Any(d => d.Name == exporter.Name)))
+                .ToList();
+
+            return (distinctExporters.ToImmutableArray(), integratedExports.ToImmutableArray());
+        }
     }
 }
diff --git a/src/BenchmarkDotNet/Configs/ManualConfig.cs b/src/BenchmarkDotNet/Configs/ManualConfig.cs
index 5ea1be24e9..1734efb070 100644
--- a/src/BenchmarkDotNet/Configs/ManualConfig.cs
+++ b/src/BenchmarkDotNet/Configs/ManualConfig.cs
@@ -3,6 +3,7 @@
 using System.ComponentModel;
 using System.Globalization;
 using System.Linq;
+using System.Reflection.Metadata;
 using BenchmarkDotNet.Analysers;
 using BenchmarkDotNet.Columns;
 using BenchmarkDotNet.Diagnosers;
@@ -25,7 +26,6 @@ public class ManualConfig : IConfig
         private readonly static Conclusion[] emptyConclusion = Array.Empty<Conclusion>();
 
         private readonly List<IColumnProvider> columnProviders = new List<IColumnProvider>();
-        private readonly List<IExporter> exporters = new List<IExporter>();
         private readonly List<ILogger> loggers = new List<ILogger>();
         private readonly List<IDiagnoser> diagnosers = new List<IDiagnoser>();
         private readonly List<IAnalyser> analysers = new List<IAnalyser>();
@@ -37,8 +37,12 @@ public class ManualConfig : IConfig
         private readonly List<EventProcessor> eventProcessors = new List<EventProcessor>();
         private readonly List<IColumnHidingRule> columnHidingRules = new List<IColumnHidingRule>();
 
+        private List<IExporter> exporters = new List<IExporter>();
+        private List<IntegratedExport> integratedExporters = new List<IntegratedExport>();
+
         public IEnumerable<IColumnProvider> GetColumnProviders() => columnProviders;
         public IEnumerable<IExporter> GetExporters() => exporters;
+        public IEnumerable<IntegratedExport> GetIntegratedExporters() => integratedExporters;
         public IEnumerable<ILogger> GetLoggers() => loggers;
         public IEnumerable<IDiagnoser> GetDiagnosers() => diagnosers;
         public IEnumerable<IAnalyser> GetAnalysers() => analysers;
@@ -109,6 +113,21 @@ public ManualConfig WithBuildTimeout(TimeSpan buildTimeout)
             return this;
         }
 
+        public ManualConfig WithSetExporters(List<IExporter> updatedExporters)
+        {
+            exporters.Clear();
+            exporters = updatedExporters;
+            return this;
+        }
+
+        public ManualConfig WithSetIntegratedExporters(List<IntegratedExport> updatedExporters)
+        {
+            integratedExporters.Clear();
+            integratedExporters.AddRange(updatedExporters);
+            return this;
+        }
+
+
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This method will soon be removed, please start using .AddColumn() instead.")]
         public void Add(params IColumn[] newColumns) => AddColumn(newColumns);
@@ -319,6 +338,8 @@ public static ManualConfig Union(IConfig globalConfig, IConfig localConfig)
             return manualConfig;
         }
 
+
+
         internal void RemoveAllJobs() => jobs.Clear();
 
         internal void RemoveAllDiagnosers() => diagnosers.Clear();
diff --git a/src/BenchmarkDotNet/Exporters/IIntegratedExports.cs b/src/BenchmarkDotNet/Exporters/IIntegratedExports.cs
new file mode 100644
index 0000000000..2f3992239a
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IIntegratedExports.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters
+{
+    internal interface IIntegratedExports
+    {
+        IEnumerable<IntegratedExportEnum> IntegratedExportEnums { get; set; }
+    }
+}
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExport.cs b/src/BenchmarkDotNet/Exporters/IntegratedExport.cs
new file mode 100644
index 0000000000..40b1dce969
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExport.cs
@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters
+{
+    public enum IntegratedExportEnum
+    {
+        HtmlExporterWithRPlotExporter,
+    }
+
+    public class IntegratedExport
+    {
+        public IntegratedExportEnum ExportEnum { get; set; }
+        public IExporter Exporter { get; set; }
+        public IExporter WithExporter { get; set; }
+        public List<IExporter> Dependencies { get; set; }
+    }
+
+    public static class IntegratedExportersMap
+    {
+        private static readonly Dictionary<IntegratedExportEnum, List<string>> ExportTypesDictionary = new Dictionary<IntegratedExportEnum, List<string>>
+        {
+            { IntegratedExportEnum.HtmlExporterWithRPlotExporter, new List<string> { nameof(RPlotExporter), nameof(HtmlExporter) } }
+        };
+
+        public static IReadOnlyDictionary<IntegratedExportEnum, List<string>> ExportTypes => ExportTypesDictionary;
+
+        public static string[] SplitEnumByWith(IntegratedExportEnum enumValue)
+        {
+            string enumString = enumValue.ToString();
+
+            return enumString.Split(new string[] { "With" }, StringSplitOptions.None);
+        }
+    }
+}
diff --git a/src/BenchmarkDotNet/Exporters/RPlotExporter.cs b/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
index c90338f490..e51d69bec4 100644
--- a/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
@@ -12,20 +12,26 @@
 
 namespace BenchmarkDotNet.Exporters
 {
-    public class RPlotExporter : IExporter, IExporterDependencies
+    public class RPlotExporter : IExporter, IExporterDependencies, IIntegratedExports
     {
+        public RPlotExporter(IntegratedExportEnum[] IntegratedExportEnums = null)
+        {
+            this.IntegratedExportEnums = IntegratedExportEnums;
+        }
+
         public static readonly IExporter Default = new RPlotExporter();
         public string Name => nameof(RPlotExporter);
 
         private const string ImageExtension = ".png";
         private static readonly object BuildScriptLock = new object();
-
         public IEnumerable<IExporter> Dependencies
         {
             // R Plots depends on having the full measurements available
             get { yield return CsvMeasurementsExporter.Default; }
         }
 
+        public IEnumerable<IntegratedExportEnum> IntegratedExportEnums { get; set; }
+
         public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
         {
             const string scriptFileName = "BuildPlots.R";
diff --git a/src/BenchmarkDotNet/Running/BenchmarkConverter.cs b/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
index 69837feec8..ee8d84cc02 100644
--- a/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
+++ b/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
@@ -7,8 +7,10 @@
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Code;
 using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Exporters;
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Filters;
+using BenchmarkDotNet.Order;
 using BenchmarkDotNet.Parameters;
 using BenchmarkDotNet.Reports;
 
@@ -16,7 +18,7 @@ namespace BenchmarkDotNet.Running
 {
     public static partial class BenchmarkConverter
     {
-        private const BindingFlags AllMethodsFlags =  BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
+        private const BindingFlags AllMethodsFlags = BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
 
         public static BenchmarkRunInfo TypeToBenchmarks(Type type, IConfig? config = null)
         {
@@ -93,6 +95,11 @@ private static ImmutableConfig GetFullTypeConfig(Type type, IConfig? config)
             foreach (var configFromAttribute in assemblyAttributes.Concat(typeAttributes))
                 config = ManualConfig.Union(config, configFromAttribute.Config);
 
+            // Check for integrated exporters
+            //IReadOnlyCollection<IntegratedExportEnum> integrationExportEnums = ExtractIntegrationExportEnums(config.GetExporters());
+            //if (integrationExportEnums.Any())
+            //    config = ProcessIntegratedConfiguration(config, integrationExportEnums);
+
             return ImmutableConfigBuilder.Create(config);
         }
 
@@ -351,5 +358,39 @@ private static object[] GetAllValidValues(Type parameterType)
 
             return new object[] { Activator.CreateInstance(parameterType) };
         }
+
+        private static IReadOnlyCollection<IntegratedExportEnum> ExtractIntegrationExportEnums(IEnumerable<IExporter> exporters)
+        {
+            return exporters
+                    .OfType<IIntegratedExports>()
+                    .Where(export => export.IntegratedExportEnums.Any())
+                    .SelectMany(export => export.IntegratedExportEnums)
+                    .ToList();
+        }
+
+        private static IConfig ProcessIntegratedConfiguration(IConfig config, IEnumerable<IntegratedExportEnum> integrationExportEnums)
+        {
+            var allExporters = config.GetExporters().ToList();
+            var integratedExports = integrationExportEnums.Select(exportEnum =>
+            {
+                var exporterTypesStr = IntegratedExportersMap.SplitEnumByWith(exportEnum);
+                return new IntegratedExport
+                {
+                    ExportEnum = exportEnum,
+                    Exporter = allExporters.FirstOrDefault(e => exporterTypesStr[0] == e.Name),
+                    WithExporter = allExporters.FirstOrDefault(e => exporterTypesStr[1] == e.Name)
+                };
+            }).ToList();
+
+            var distinctExporters = allExporters
+                    .Where(exporter => !integratedExports
+                    .Any(integrated => integrated.Exporter.Name == exporter.Name ||
+                                     integrated.WithExporter.Name == exporter.Name))
+                .ToList();
+
+            return config
+                .WithSetExporters(distinctExporters)
+                .WithSetIntegratedExporters(integratedExports);
+        }
     }
 }
diff --git a/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs b/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
index 6d9d48c3cc..f1311d4a34 100644
--- a/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
+++ b/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
@@ -292,6 +292,7 @@ private static void PrintSummary(ILogger logger, ImmutableConfig config, Summary
 
             logger.WriteLineHeader("// * Export *");
             string currentDirectory = Directory.GetCurrentDirectory();
+            List<dynamic> additionalData = new List<dynamic>();
             foreach (string file in config.GetCompositeExporter().ExportToFiles(summary, logger))
             {
                 logger.WriteLineInfo($"  {file.GetBaseName(currentDirectory)}");

From a81417edbc086a5c169a14dbb34071f512de06c1 Mon Sep 17 00:00:00 2001
From: Avishai Dotan <108017307+AvishaiDotan@users.noreply.github.com>
Date: Fri, 10 Jan 2025 11:35:33 +0200
Subject: [PATCH 2/5] integrate html with rplot

---
 .../Exporters/RPlotExporterAttribute.cs       |   4 -
 .../Configs/ImmutableConfig.cs                |   2 +-
 .../Configs/ImmutableConfigBuilder.cs         |   2 +-
 .../Exporters/CompositeExporter.cs            |  73 +++++++++--
 src/BenchmarkDotNet/Exporters/ExporterBase.cs |   2 +-
 src/BenchmarkDotNet/Exporters/HtmlExporter.cs |  19 ++-
 .../Exporters/IIntegratedExports.cs           |   7 +-
 .../Exporters/IntegratedExporterExtension.cs  |  45 +++++++
 .../Exporters/RPlotExporter.cs                | 122 +++++++++++++++++-
 .../Running/BenchmarkRunnerClean.cs           |  10 +-
 10 files changed, 264 insertions(+), 22 deletions(-)
 create mode 100644 src/BenchmarkDotNet/Exporters/IntegratedExporterExtension.cs

diff --git a/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs b/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs
index e9bb97efde..f48bd7c46f 100644
--- a/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs
+++ b/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs
@@ -6,10 +6,6 @@ namespace BenchmarkDotNet.Attributes
 {
     public class RPlotExporterAttribute : ExporterConfigBaseAttribute
     {
-        /// <param name="reportDependencies">
-        /// Determines whether Rplot exported images should be added to the HTML report (a.k.a HTML report).
-        /// False by default (rplotImages will not be displayed).
-        /// </param>
         protected RPlotExporterAttribute()
         {}
 
diff --git a/src/BenchmarkDotNet/Configs/ImmutableConfig.cs b/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
index 06ff27ee8e..e14b076871 100644
--- a/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
+++ b/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
@@ -95,7 +95,6 @@ internal ImmutableConfig(
 
         public IEnumerable<IColumnProvider> GetColumnProviders() => columnProviders;
         public IEnumerable<IExporter> GetExporters() => exporters;
-
         public IEnumerable<IntegratedExport> GetIntegratedExports() => integratedExports;
         public IEnumerable<ILogger> GetLoggers() => loggers;
         public IEnumerable<IDiagnoser> GetDiagnosers() => diagnosers;
@@ -110,6 +109,7 @@ internal ImmutableConfig(
 
         public ILogger GetCompositeLogger() => new CompositeLogger(loggers);
         public IExporter GetCompositeExporter() => new CompositeExporter(exporters);
+        public IExporter GetCompositeIntegratedExporter() => new CompositeExporter(integratedExports);
         public IValidator GetCompositeValidator() => new CompositeValidator(validators);
         public IAnalyser GetCompositeAnalyser() => new CompositeAnalyser(analysers);
         public IDiagnoser GetCompositeDiagnoser() => new CompositeDiagnoser(diagnosers);
diff --git a/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs b/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
index cd7cb6611a..e3d416d529 100644
--- a/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
+++ b/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
@@ -263,7 +263,7 @@ private static IReadOnlyCollection<IntegratedExportEnum> ExtractIntegrationExpor
         {
             return exporters
                     .OfType<IIntegratedExports>()
-                    .Where(export => export.IntegratedExportEnums.Any())
+                    .Where(export => export?.IntegratedExportEnums?.Any() ?? false)
                     .SelectMany(export => export.IntegratedExportEnums)
                     .ToList();
         }
diff --git a/src/BenchmarkDotNet/Exporters/CompositeExporter.cs b/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
index 95d3bde9d3..7e70a05a82 100644
--- a/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
@@ -11,9 +11,12 @@ namespace BenchmarkDotNet.Exporters
     public class CompositeExporter : IExporter
     {
         private readonly ImmutableArray<IExporter> exporters;
+        private readonly ImmutableArray<IntegratedExport> integratedExports;
 
         public CompositeExporter(ImmutableArray<IExporter> exporters) => this.exporters = exporters;
 
+        public CompositeExporter(ImmutableArray<IntegratedExport> integratedExports) => this.integratedExports = integratedExports;
+
         public string Name => nameof(CompositeExporter);
 
         public void ExportToLog(Summary summary, ILogger logger)
@@ -35,18 +38,68 @@ public void ExportToLog(Summary summary, ILogger logger)
         }
 
         public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
-            => exporters.SelectMany(exporter =>
+        {
+            if (exporters != null && exporters.Any())
             {
-                var files = new List<string>();
-                try
+                return exporters.SelectMany(exporter =>
                 {
-                    files.AddRange(exporter.ExportToFiles(summary, consoleLogger));
-                }
-                catch (Exception e)
+                    var files = new List<string>();
+                    try
+                    {
+                        files.AddRange(exporter.ExportToFiles(summary, consoleLogger));
+                    }
+                    catch (Exception e)
+                    {
+                        consoleLogger.WriteLineError(e.ToString());
+                    }
+                    return files;
+                });
+            }
+            else if (integratedExports != null && integratedExports.Any())
+            {
+                return integratedExports.SelectMany(exporter =>
                 {
-                    consoleLogger.WriteLineError(e.ToString());
-                }
-                return files;
-            });
+                    var files = new List<string>();
+                    IEnumerable<string> dependencyFilePaths = new List<string>();
+                    try
+                    {
+                        if (exporter.Dependencies.Any())
+                        {
+                            exporter.Dependencies.ForEach(d =>
+                            {
+                                files.AddRange(d.ExportToFiles(summary, consoleLogger));
+                            });
+                        }
+                        if (exporter.WithExporter != null)
+                        {
+                            files.AddRange(exporter.WithExporter.ExportToFiles(summary, consoleLogger));
+                        }
+                        if (exporter.Exporter != null && exporter.Exporter is IntegratedExporterExtension exporterBase)
+                        {
+                            object? payload = null;
+                            switch (exporter.ExportEnum)
+                            {
+                                case IntegratedExportEnum.HtmlExporterWithRPlotExporter:
+                                    if (exporter.WithExporter is RPlotExporter rPlotExporter)
+                                    {
+                                        payload = rPlotExporter.GetExpectedPngPaths(summary, consoleLogger);
+                                    }
+                                    break;
+                            }
+                            files.AddRange(exporterBase.IntegratedExportToFiles(summary, consoleLogger, payload));
+                        }
+                    }
+                    catch (Exception e)
+                    {
+                        consoleLogger.WriteLineError(e.ToString());
+                    }
+                    return files;
+                });
+            }
+            else
+            {
+                return Array.Empty<string>();
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Exporters/ExporterBase.cs b/src/BenchmarkDotNet/Exporters/ExporterBase.cs
index 17a8d432a6..527798b2ae 100644
--- a/src/BenchmarkDotNet/Exporters/ExporterBase.cs
+++ b/src/BenchmarkDotNet/Exporters/ExporterBase.cs
@@ -54,7 +54,7 @@ internal string GetArtifactFullName(Summary summary)
             return $"{Path.Combine(summary.ResultsDirectoryPath, fileName)}-{FileCaption}{FileNameSuffix}.{FileExtension}";
         }
 
-        private static string GetFileName(Summary summary)
+        protected static string GetFileName(Summary summary)
         {
             // we can't use simple name here, because user might be running benchmarks for a library,  which defines few types with the same name
             // and reports the results per type, so every summary is going to contain just single benchmark
diff --git a/src/BenchmarkDotNet/Exporters/HtmlExporter.cs b/src/BenchmarkDotNet/Exporters/HtmlExporter.cs
index 8fe3068e14..eb290c87a3 100644
--- a/src/BenchmarkDotNet/Exporters/HtmlExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/HtmlExporter.cs
@@ -1,10 +1,12 @@
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Reports;
+using System;
+using System.Collections.Generic;
 
 namespace BenchmarkDotNet.Exporters
 {
-    public class HtmlExporter : ExporterBase
+    public class HtmlExporter : IntegratedExporterExtension
     {
         private const string CssDefinition = @"
 <style type=""text/css"">
@@ -23,7 +25,7 @@ public override void ExportToLog(Summary summary, ILogger logger)
             PrintAll(summary, new HtmlLoggerWrapper(logger));
         }
 
-        private static void PrintAll(Summary summary, ILogger logger)
+        private static void PrintAll(Summary summary, ILogger logger, List<string>? moreData = null)
         {
             logger.WriteLine("<!DOCTYPE html>");
             logger.WriteLine("<html lang='en'>");
@@ -46,6 +48,14 @@ private static void PrintAll(Summary summary, ILogger logger)
 
             PrintTable(summary.Table, logger);
 
+            if (moreData != null)
+            {
+                foreach (var item in moreData)
+                {
+                    logger.WriteLine($"<img src='{item}'/>");
+                }
+            }
+
             logger.WriteLine("</body>");
             logger.WriteLine("</html>");
         }
@@ -96,6 +106,11 @@ private static void PrintLine(SummaryTable table, string[] line, ILogger logger,
             logger.WriteLine();
         }
 
+        public override void IntegratedExportToLog(Summary summary, ILogger logger, object moreData)
+        {
+            PrintAll(summary, logger, moreData as List<string>);
+        }
+
         private class HtmlLoggerWrapper : ILogger
         {
             private readonly ILogger internalLogger;
diff --git a/src/BenchmarkDotNet/Exporters/IIntegratedExports.cs b/src/BenchmarkDotNet/Exporters/IIntegratedExports.cs
index 2f3992239a..bc0b1bde3d 100644
--- a/src/BenchmarkDotNet/Exporters/IIntegratedExports.cs
+++ b/src/BenchmarkDotNet/Exporters/IIntegratedExports.cs
@@ -1,5 +1,10 @@
-using System;
+using BenchmarkDotNet.Helpers;
+using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Reports;
+using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
 using System.Text;
 
 namespace BenchmarkDotNet.Exporters
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporterExtension.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporterExtension.cs
new file mode 100644
index 0000000000..81e8952e0c
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporterExtension.cs
@@ -0,0 +1,45 @@
+using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Reports;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters
+{
+    public abstract class IntegratedExporterExtension : ExporterBase
+    {
+        public abstract void IntegratedExportToLog(Summary summary, ILogger logger, object moreData);
+
+        public IEnumerable<string> IntegratedExportToFiles(Summary summary, ILogger consoleLogger, object moreData = null)
+        {
+            string fileName = GetFileName(summary);
+            string filePath = GetArtifactFullName(summary);
+            if (File.Exists(filePath))
+            {
+                try
+                {
+                    File.Delete(filePath);
+                }
+                catch (IOException)
+                {
+                    string uniqueString = DateTime.Now.ToString("yyyyMMdd-HHmmss");
+                    string alternativeFilePath = $"{Path.Combine(summary.ResultsDirectoryPath, fileName)}-{FileCaption}{FileNameSuffix}-{uniqueString}.{FileExtension}";
+                    consoleLogger.WriteLineError($"Could not overwrite file {filePath}. Exporting to {alternativeFilePath}");
+                    filePath = alternativeFilePath;
+                }
+            }
+
+            using (var stream = new StreamWriter(filePath, append: false))
+            {
+                using (var streamLogger = new StreamLogger(stream))
+                {
+                    IntegratedExportToLog(summary, streamLogger, moreData);
+                }
+            }
+
+            return new[] { filePath };
+        }
+
+    }
+}
diff --git a/src/BenchmarkDotNet/Exporters/RPlotExporter.cs b/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
index e51d69bec4..4ea9790cb2 100644
--- a/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
+using System.Threading;
 using BenchmarkDotNet.Detectors;
 using BenchmarkDotNet.Exporters.Csv;
 using BenchmarkDotNet.Helpers;
@@ -63,7 +65,7 @@ public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
                 WorkingDirectory = summary.ResultsDirectoryPath,
                 Arguments = $"\"{scriptFullPath}\" \"{csvFullPath}\""
             };
-            using (var process = new Process {StartInfo = start})
+            using (var process = new Process { StartInfo = start })
             using (AsyncProcessOutputReader reader = new AsyncProcessOutputReader(process))
             {
                 // When large R scripts are generated then ran, ReadToEnd()
@@ -153,5 +155,123 @@ private static bool TryFindRScript(ILogger consoleLogger, out string? rscriptPat
             }
             return null;
         }
+
+        public List<string> GetExpectedPngPaths(Summary summary, ILogger consoleLogger)
+        {
+            const string scriptFileName = "get-png-paths-script.R";
+            var pngPaths = new List<string>();
+
+            // Create R script content
+            string script = @"
+if (!require(dplyr)) install.packages('dplyr')
+library(dplyr)
+
+ends_with <- function(vars, match, ignore.case = TRUE) {
+  if (ignore.case) match <- tolower(match)
+  n <- nchar(match)
+  if (ignore.case) vars <- tolower(vars)
+  length <- nchar(vars)
+  substr(vars, pmax(1, length - n + 1), length) == match
+}
+
+list_benchmark_png_paths <- function(measurement_files) {
+  paths <- c()
+  for (file in measurement_files) {
+    title <- gsub('-measurements.csv', '', basename(file))
+    paths <- c(paths,
+              gsub('-measurements.csv', '-boxplot.png', file),
+              gsub('-measurements.csv', '-barplot.png', file))
+    
+    measurements <- read.csv(file, sep = ',')
+    result <- measurements %>% filter(Measurement_IterationStage == 'Result')
+    
+    for (target in unique(result$Target_Method)) {
+      paths <- c(paths,
+                gsub('-measurements.csv', paste0('-', target, '-density.png'), file),
+                gsub('-measurements.csv', paste0('-', target, '-facetDensity.png'), file),
+                gsub('-measurements.csv', paste0('-', target, '-facetTimeline.png'), file),
+                gsub('-measurements.csv', paste0('-', target, '-facetTimelineSmooth.png'), file),
+                gsub('-measurements.csv', paste0('-', target, '-cummean.png'), file))
+      
+      df <- result %>% filter(Target_Method == target)
+      
+      for (params in unique(df$Params)) {
+        if (!is.na(params)) {
+          prefix <- paste0('-', target, '-', params)
+          paths <- c(paths,
+                    gsub('-measurements.csv', paste0(prefix, '-density.png'), file),
+                    gsub('-measurements.csv', paste0(prefix, '-facetDensity.png'), file))
+        }
+      }
+      
+      for (job in unique(df$Job_Id)) {
+        if (!is.na(job)) {
+          paths <- c(paths,
+                    gsub('-measurements.csv', paste0('-', target, '-', job, '-timeline.png'), file),
+                    gsub('-measurements.csv', paste0('-', target, '-', job, '-timelineSmooth.png'), file),
+                    gsub('-measurements.csv', paste0('-', target, '-', job, '-cummean.png'), file),
+                    gsub('-measurements.csv', paste0('-', target, '-', job, '-density.png'), file))
+        }
+      }
+    }
+  }
+  return(unique(paths))
+}
+
+files <- list.files(pattern = '*-measurements.csv')
+if (length(files) > 0) {
+  png_paths <- list_benchmark_png_paths(files)
+  cat(png_paths, sep='\n')
+}";
+
+            // Write script file
+            string scriptFullPath = Path.Combine(summary.ResultsDirectoryPath, scriptFileName);
+            File.WriteAllText(scriptFullPath, script);
+
+            // Find RScript executable
+            if (!TryFindRScript(consoleLogger, out string rscriptPath))
+            {
+                throw new InvalidOperationException("RScript executable not found");
+            }
+
+            // Prepare process
+            var startInfo = new ProcessStartInfo
+            {
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true,
+                FileName = rscriptPath,
+                WorkingDirectory = summary.ResultsDirectoryPath,
+                Arguments = $"\"{scriptFullPath}\""
+            };
+
+            // Execute and collect output
+            using (var process = new Process { StartInfo = startInfo })
+            {
+                var output = new List<string>();
+                var outputDone = new ManualResetEventSlim();
+
+                process.OutputDataReceived += (sender, e) =>
+                {
+                    if (e.Data == null)
+                        outputDone.Set();
+                    else if (e.Data.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
+                        output.Add(e.Data.Trim());
+                };
+
+                process.Start();
+                process.BeginOutputReadLine();
+                process.WaitForExit();
+                outputDone.Wait();
+
+                // Convert relative paths to full paths
+                pngPaths.AddRange(output.Select(p => Path.Combine(summary.ResultsDirectoryPath, p)));
+
+                outputDone.Dispose();
+            }
+
+            return pngPaths;
+        }
     }
 }
diff --git a/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs b/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
index f1311d4a34..454cc12427 100644
--- a/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
+++ b/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
@@ -292,12 +292,20 @@ private static void PrintSummary(ILogger logger, ImmutableConfig config, Summary
 
             logger.WriteLineHeader("// * Export *");
             string currentDirectory = Directory.GetCurrentDirectory();
-            List<dynamic> additionalData = new List<dynamic>();
             foreach (string file in config.GetCompositeExporter().ExportToFiles(summary, logger))
             {
                 logger.WriteLineInfo($"  {file.GetBaseName(currentDirectory)}");
             }
 
+            //if (config.GetIntegratedExports().Any())
+            //{
+            //    foreach (string file in config.GetCompositeIntegratedExporter().ExportToFiles(summary, logger))
+            //    {
+            //        logger.WriteLineInfo($"  {file.GetBaseName(currentDirectory)}");
+            //    }
+            //}
+
+
             logger.WriteLine();
 
             logger.WriteLineHeader("// * Detailed results *");

From b2446d6cb1fc73fc84a88be549532867e1368a8f Mon Sep 17 00:00:00 2001
From: Avishai Dotan <108017307+AvishaiDotan@users.noreply.github.com>
Date: Fri, 17 Jan 2025 15:00:01 +0200
Subject: [PATCH 3/5] CHANGES

---
 .../IntroIntegratedExporter.cs                | 31 +++++++
 samples/BenchmarkDotNet.Samples/IntroRPlot.cs |  2 +-
 samples/BenchmarkDotNet.Samples/Program.cs    |  2 +-
 .../Exporters/IntegratedExporterAttribute.cs  | 17 ++++
 .../IntegratedExporterConfigBaseAttribute.cs  | 25 ++++++
 .../Exporters/RPlotExporterAttribute.cs       |  4 +-
 .../Configs/ConfigExtensions.cs               |  4 +-
 src/BenchmarkDotNet/Configs/DebugConfig.cs    |  3 +
 src/BenchmarkDotNet/Configs/DefaultConfig.cs  |  7 ++
 src/BenchmarkDotNet/Configs/IConfig.cs        |  2 +
 .../Configs/ImmutableConfig.cs                | 11 +--
 .../Configs/ImmutableConfigBuilder.cs         | 52 +++---------
 src/BenchmarkDotNet/Configs/ManualConfig.cs   | 39 +++++----
 .../Exporters/CompositeExporter.cs            | 85 +++++++++----------
 .../Exporters/IIntegratedExports.cs           | 16 ----
 .../Exporters/IntegratedExport.cs             | 36 --------
 .../CompositeIntegratedExporter.cs            | 72 ++++++++++++++++
 .../IntegratedExporter/IIntegratedExporter.cs | 17 ++++
 .../IntegratedExportType.cs                   | 11 +++
 .../IntegratedExporter/IntegratedExporter.cs  | 34 ++++++++
 .../IntegratedExporterData.cs                 | 13 +++
 .../Exporters/RPlotExporter.cs                |  9 +-
 .../Running/BenchmarkConverter.cs             | 71 +++++++---------
 23 files changed, 350 insertions(+), 213 deletions(-)
 create mode 100644 samples/BenchmarkDotNet.Samples/IntroIntegratedExporter.cs
 create mode 100644 src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterAttribute.cs
 create mode 100644 src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterConfigBaseAttribute.cs
 delete mode 100644 src/BenchmarkDotNet/Exporters/IIntegratedExports.cs
 delete mode 100644 src/BenchmarkDotNet/Exporters/IntegratedExport.cs
 create mode 100644 src/BenchmarkDotNet/Exporters/IntegratedExporter/CompositeIntegratedExporter.cs
 create mode 100644 src/BenchmarkDotNet/Exporters/IntegratedExporter/IIntegratedExporter.cs
 create mode 100644 src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExportType.cs
 create mode 100644 src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporter.cs
 create mode 100644 src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterData.cs

diff --git a/samples/BenchmarkDotNet.Samples/IntroIntegratedExporter.cs b/samples/BenchmarkDotNet.Samples/IntroIntegratedExporter.cs
new file mode 100644
index 0000000000..b617edc1b4
--- /dev/null
+++ b/samples/BenchmarkDotNet.Samples/IntroIntegratedExporter.cs
@@ -0,0 +1,31 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Attributes.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BenchmarkDotNet.Samples
+{
+    [IntegratedExporter(IntegratedExportType.HtmlExporterWithRPlotExporter)]
+    public class IntroIntegratedExporter
+    {
+        [Benchmark]
+        public void Benchmark()
+        {
+            var result = Calculate();
+        }
+
+        private int Calculate()
+        {
+            int sum = 0;
+            for (int i = 0; i < 1000; i++)
+            {
+                sum += i;
+            }
+            return sum;
+        }
+    }
+}
diff --git a/samples/BenchmarkDotNet.Samples/IntroRPlot.cs b/samples/BenchmarkDotNet.Samples/IntroRPlot.cs
index e72bde95ce..6e6b258038 100644
--- a/samples/BenchmarkDotNet.Samples/IntroRPlot.cs
+++ b/samples/BenchmarkDotNet.Samples/IntroRPlot.cs
@@ -7,7 +7,7 @@ namespace BenchmarkDotNet.Samples
 {
     //[MemoryDiagnoser]
     //[Config(typeof(Config))]
-    [RPlotExporter(IntegratedExportEnum.HtmlExporterWithRPlotExporter)]
+    [RPlotExporter]
     public class IntroRPlot
     {
         [Benchmark]
diff --git a/samples/BenchmarkDotNet.Samples/Program.cs b/samples/BenchmarkDotNet.Samples/Program.cs
index 230d26f2f2..440e27b4b8 100644
--- a/samples/BenchmarkDotNet.Samples/Program.cs
+++ b/samples/BenchmarkDotNet.Samples/Program.cs
@@ -5,6 +5,6 @@ namespace BenchmarkDotNet.Samples
     public class Program
     {
         //public static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
-        public static void Main(string[] args) => BenchmarkRunner.Run<IntroRPlot>();
+        public static void Main(string[] args) => BenchmarkRunner.Run<IntroIntegratedExporter>();
     }
 }
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterAttribute.cs b/src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterAttribute.cs
new file mode 100644
index 0000000000..407b232435
--- /dev/null
+++ b/src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterAttribute.cs
@@ -0,0 +1,17 @@
+using BenchmarkDotNet.Exporters.IntegratedExporter;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BenchmarkDotNet.Attributes.Exporters
+{
+    public class IntegratedExporterAttribute : IntegratedExporterConfigBaseAttribute
+    {
+        protected IntegratedExporterAttribute()
+        { }
+
+        public IntegratedExporterAttribute(IntegratedExportType integratedExporterType) : base(integratedExporterType)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterConfigBaseAttribute.cs b/src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterConfigBaseAttribute.cs
new file mode 100644
index 0000000000..155641a70b
--- /dev/null
+++ b/src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterConfigBaseAttribute.cs
@@ -0,0 +1,25 @@
+using System;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
+using JetBrains.Annotations;
+
+namespace BenchmarkDotNet.Attributes
+{
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Assembly)]
+    public class IntegratedExporterConfigBaseAttribute : Attribute, IConfigSource
+    {
+        // CLS-Compliant Code requires a constructor without an array in the argument list
+        [PublicAPI]
+        protected IntegratedExporterConfigBaseAttribute()
+        {
+            Config = ManualConfig.CreateEmpty();
+        }
+
+        protected IntegratedExporterConfigBaseAttribute(IntegratedExportType exporter)
+        {
+            Config = ManualConfig.CreateEmpty().SetIntegratedExporterType(exporter);
+        }
+
+        public IConfig Config { get; }
+    }
+}
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs b/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs
index f48bd7c46f..9909559e35 100644
--- a/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs
+++ b/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs
@@ -6,10 +6,8 @@ namespace BenchmarkDotNet.Attributes
 {
     public class RPlotExporterAttribute : ExporterConfigBaseAttribute
     {
-        protected RPlotExporterAttribute()
-        {}
 
-        public RPlotExporterAttribute(params IntegratedExportEnum[] integratedExportEnums) : base(new RPlotExporter(integratedExportEnums))
+        public RPlotExporterAttribute() : base(new RPlotExporter())
         {
         }
     }
diff --git a/src/BenchmarkDotNet/Configs/ConfigExtensions.cs b/src/BenchmarkDotNet/Configs/ConfigExtensions.cs
index 3d6730f0ac..ec7f8e31a5 100644
--- a/src/BenchmarkDotNet/Configs/ConfigExtensions.cs
+++ b/src/BenchmarkDotNet/Configs/ConfigExtensions.cs
@@ -37,6 +37,7 @@ public static class ConfigExtensions
         [Obsolete("This method will soon be removed, please start using .AddExporter() instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)] public static IConfig With(this IConfig config, params IExporter[] exporters) => config.AddExporter(exporters);
         [PublicAPI] public static ManualConfig AddExporter(this IConfig config, params IExporter[] exporters) => config.With(m => m.AddExporter(exporters));
+        [PublicAPI] public static ManualConfig AddIntegratedExporter(this IConfig config, List<IExporter>? dependencies, IExporter withExporter, IExporter exporter) => config.With(m => m.AddIntegratedExporter(dependencies, withExporter, exporter));
 
         [Obsolete("This method will soon be removed, please start using .AddDiagnoser() instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)] public static IConfig With(this IConfig config, params IDiagnoser[] diagnosers) => config.AddDiagnoser(diagnosers);
@@ -77,9 +78,6 @@ public static class ConfigExtensions
         [PublicAPI] public static ManualConfig WithUnionRule(this IConfig config, ConfigUnionRule unionRule) => config.With(m => m.WithUnionRule(unionRule));
         [PublicAPI] public static ManualConfig WithCultureInfo(this IConfig config, CultureInfo cultureInfo) => config.With(m => m.CultureInfo = cultureInfo);
 
-        [PublicAPI] public static ManualConfig WithSetExporters(this IConfig config, List<IExporter> exporters) => config.With(m => m.WithSetExporters(exporters));
-        [PublicAPI] public static ManualConfig WithSetIntegratedExporters(this IConfig config, List<IntegratedExport> exporters) => config.With(m => m.WithSetIntegratedExporters(exporters));
-
         /// <summary>
         /// determines if all auto-generated files should be kept or removed after running the benchmarks
         /// </summary>
diff --git a/src/BenchmarkDotNet/Configs/DebugConfig.cs b/src/BenchmarkDotNet/Configs/DebugConfig.cs
index 0fdda7b08d..6a11383d13 100644
--- a/src/BenchmarkDotNet/Configs/DebugConfig.cs
+++ b/src/BenchmarkDotNet/Configs/DebugConfig.cs
@@ -6,6 +6,7 @@
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
@@ -58,6 +59,8 @@ public abstract class DebugConfig : IConfig
         public IEnumerable<IValidator> GetValidators() => Array.Empty<IValidator>();
         public IEnumerable<IColumnProvider> GetColumnProviders() => DefaultColumnProviders.Instance;
         public IEnumerable<IExporter> GetExporters() => Array.Empty<IExporter>();
+        public IEnumerable<IntegratedExporterData> GetIntegratedExporters() => Array.Empty<IntegratedExporterData>();
+        public IIntegratedExporter GetIntegratedExporter() => null;
         public IEnumerable<ILogger> GetLoggers() => new[] { ConsoleLogger.Default };
         public IEnumerable<IDiagnoser> GetDiagnosers() => Array.Empty<IDiagnoser>();
         public IEnumerable<IAnalyser> GetAnalysers() => Array.Empty<IAnalyser>();
diff --git a/src/BenchmarkDotNet/Configs/DefaultConfig.cs b/src/BenchmarkDotNet/Configs/DefaultConfig.cs
index e1cf0e3b8a..291f462dcd 100644
--- a/src/BenchmarkDotNet/Configs/DefaultConfig.cs
+++ b/src/BenchmarkDotNet/Configs/DefaultConfig.cs
@@ -9,6 +9,7 @@
 using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
 using BenchmarkDotNet.Exporters.Csv;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
@@ -40,6 +41,10 @@ public IEnumerable<IExporter> GetExporters()
             yield return HtmlExporter.Default;
         }
 
+        public IEnumerable<IntegratedExporterData> GetIntegratedExporters() => Array.Empty<IntegratedExporterData>();
+
+        public IIntegratedExporter GetIntegratedExporter() => null;
+
         public IEnumerable<ILogger> GetLoggers()
         {
             if (LinqPadLogger.IsAvailable)
@@ -113,5 +118,7 @@ public string ArtifactsPath
         public IEnumerable<EventProcessor> GetEventProcessors() => Array.Empty<EventProcessor>();
 
         public IEnumerable<IColumnHidingRule> GetColumnHidingRules() => Array.Empty<IColumnHidingRule>();
+
+
     }
 }
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Configs/IConfig.cs b/src/BenchmarkDotNet/Configs/IConfig.cs
index b311c235f5..94965960b9 100644
--- a/src/BenchmarkDotNet/Configs/IConfig.cs
+++ b/src/BenchmarkDotNet/Configs/IConfig.cs
@@ -6,6 +6,7 @@
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
@@ -20,6 +21,7 @@ public interface IConfig
     {
         IEnumerable<IColumnProvider> GetColumnProviders();
         IEnumerable<IExporter> GetExporters();
+        IEnumerable<IntegratedExporterData> GetIntegratedExporters();
         IEnumerable<ILogger> GetLoggers();
         IEnumerable<IDiagnoser> GetDiagnosers();
         IEnumerable<IAnalyser> GetAnalysers();
diff --git a/src/BenchmarkDotNet/Configs/ImmutableConfig.cs b/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
index e14b076871..73bce58ff0 100644
--- a/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
+++ b/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
@@ -8,6 +8,7 @@
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
@@ -24,7 +25,7 @@ public sealed class ImmutableConfig : IConfig
         // if something is an array here instead of hashset it means it must have a guaranteed order of elements
         private readonly ImmutableArray<IColumnProvider> columnProviders;
         private readonly ImmutableArray<IExporter> exporters;
-        private readonly ImmutableArray<IntegratedExport> integratedExports;
+        private readonly ImmutableArray<IntegratedExporterData> integratedExporters;
         private readonly ImmutableHashSet<ILogger> loggers;
         private readonly ImmutableHashSet<IDiagnoser> diagnosers;
         private readonly ImmutableHashSet<IAnalyser> analysers;
@@ -42,7 +43,7 @@ internal ImmutableConfig(
             ImmutableHashSet<HardwareCounter> uniqueHardwareCounters,
             ImmutableHashSet<IDiagnoser> uniqueDiagnosers,
             ImmutableArray<IExporter> uniqueExporters,
-            ImmutableArray<IntegratedExport> uniqueIntegratedExports,
+            ImmutableArray<IntegratedExporterData> uniqueIntegratedExporters,
             ImmutableHashSet<IAnalyser> uniqueAnalyzers,
             ImmutableHashSet<IValidator> uniqueValidators,
             ImmutableHashSet<IFilter> uniqueFilters,
@@ -65,7 +66,7 @@ internal ImmutableConfig(
             hardwareCounters = uniqueHardwareCounters;
             diagnosers = uniqueDiagnosers;
             exporters = uniqueExporters;
-            integratedExports = uniqueIntegratedExports;
+            integratedExporters = uniqueIntegratedExporters;
             analysers = uniqueAnalyzers;
             validators = uniqueValidators;
             filters = uniqueFilters;
@@ -95,7 +96,7 @@ internal ImmutableConfig(
 
         public IEnumerable<IColumnProvider> GetColumnProviders() => columnProviders;
         public IEnumerable<IExporter> GetExporters() => exporters;
-        public IEnumerable<IntegratedExport> GetIntegratedExports() => integratedExports;
+        public IEnumerable<IntegratedExporterData> GetIntegratedExporters() => integratedExporters;
         public IEnumerable<ILogger> GetLoggers() => loggers;
         public IEnumerable<IDiagnoser> GetDiagnosers() => diagnosers;
         public IEnumerable<IAnalyser> GetAnalysers() => analysers;
@@ -109,7 +110,7 @@ internal ImmutableConfig(
 
         public ILogger GetCompositeLogger() => new CompositeLogger(loggers);
         public IExporter GetCompositeExporter() => new CompositeExporter(exporters);
-        public IExporter GetCompositeIntegratedExporter() => new CompositeExporter(integratedExports);
+        public IExporter GetCompositeIntegratedExporter() => new CompositeIntegratedExporter(integratedExporters);
         public IValidator GetCompositeValidator() => new CompositeValidator(validators);
         public IAnalyser GetCompositeAnalyser() => new CompositeAnalyser(analysers);
         public IDiagnoser GetCompositeDiagnoser() => new CompositeDiagnoser(diagnosers);
diff --git a/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs b/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
index e3d416d529..0e00fbeaa1 100644
--- a/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
+++ b/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
@@ -4,6 +4,7 @@
 using BenchmarkDotNet.Analysers;
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Order;
 using BenchmarkDotNet.Reports;
@@ -43,10 +44,19 @@ public static ImmutableConfig Create(IConfig source)
 
             var uniqueHardwareCounters = source.GetHardwareCounters().Where(counter => counter != HardwareCounter.NotSet).ToImmutableHashSet();
             var uniqueDiagnosers = GetDiagnosers(source.GetDiagnosers(), uniqueHardwareCounters);
+
+            var integratedExporters = source?.GetIntegratedExporters();
+            if (integratedExporters is not null && integratedExporters.Count() > 0)
+            {
+                var distinctExporters = source.GetExporters().DistinctBy(e =>
+                {
+                    bool hasIntegratedExporter = source
+                })
+            }
+
             var allExporters = GetExporters(source.GetExporters(), uniqueDiagnosers, configAnalyse);
 
             // Check for integrated exporters
-            var (uniqueExporters, integratedExports) = ProcessIntegratedConfiguration(allExporters);
             var uniqueAnalyzers = GetAnalysers(source.GetAnalysers(), uniqueDiagnosers);
 
             var uniqueValidators = GetValidators(source.GetValidators(), MandatoryValidators, source.Options);
@@ -63,8 +73,8 @@ public static ImmutableConfig Create(IConfig source)
                 uniqueLoggers,
                 uniqueHardwareCounters,
                 uniqueDiagnosers,
-                uniqueExporters,
-                integratedExports,
+                allExporters,
+                new ImmutableArray<IntegratedExporterData>(),
                 uniqueAnalyzers,
                 uniqueValidators,
                 uniqueFilters,
@@ -258,41 +268,5 @@ private class TypeComparer<TInterface> : IEqualityComparer<TInterface>
 
             public int GetHashCode(TInterface obj) => obj.GetType().GetHashCode();
         }
-
-        private static IReadOnlyCollection<IntegratedExportEnum> ExtractIntegrationExportEnums(IEnumerable<IExporter> exporters)
-        {
-            return exporters
-                    .OfType<IIntegratedExports>()
-                    .Where(export => export?.IntegratedExportEnums?.Any() ?? false)
-                    .SelectMany(export => export.IntegratedExportEnums)
-                    .ToList();
-        }
-
-        private static (ImmutableArray<IExporter> UniqueExporters, ImmutableArray<IntegratedExport> IntegratedExports) ProcessIntegratedConfiguration(ImmutableArray<IExporter> allExporters)
-        {
-            var integratedExportEnums = ExtractIntegrationExportEnums(allExporters);
-            var integratedExports = integratedExportEnums.Select(exportEnum =>
-            {
-                var exporterTypesStr = IntegratedExportersMap.SplitEnumByWith(exportEnum);
-                return new IntegratedExport
-                {
-                    ExportEnum = exportEnum,
-                    Exporter = allExporters.FirstOrDefault(e => exporterTypesStr[0] == e.Name),
-                    WithExporter = allExporters.FirstOrDefault(e => exporterTypesStr[1] == e.Name),
-                    Dependencies = allExporters
-                                    .Where(exporter => exporter is IExporterDependencies)
-                                    .SelectMany(exporter => (exporter as IExporterDependencies).Dependencies)
-                                    .ToList()
-                };
-            }).ToList();
-
-            var distinctExporters = allExporters
-                .Where(exporter => !integratedExports
-                 .Any(integrated => integrated.Exporter?.Name == exporter.Name ||
-                                    integrated.WithExporter?.Name == exporter.Name || !integrated.Dependencies.Any(d => d.Name == exporter.Name)))
-                .ToList();
-
-            return (distinctExporters.ToImmutableArray(), integratedExports.ToImmutableArray());
-        }
     }
 }
diff --git a/src/BenchmarkDotNet/Configs/ManualConfig.cs b/src/BenchmarkDotNet/Configs/ManualConfig.cs
index 1734efb070..5110dde0cb 100644
--- a/src/BenchmarkDotNet/Configs/ManualConfig.cs
+++ b/src/BenchmarkDotNet/Configs/ManualConfig.cs
@@ -9,6 +9,7 @@
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
@@ -24,7 +25,6 @@ namespace BenchmarkDotNet.Configs
     public class ManualConfig : IConfig
     {
         private readonly static Conclusion[] emptyConclusion = Array.Empty<Conclusion>();
-
         private readonly List<IColumnProvider> columnProviders = new List<IColumnProvider>();
         private readonly List<ILogger> loggers = new List<ILogger>();
         private readonly List<IDiagnoser> diagnosers = new List<IDiagnoser>();
@@ -38,11 +38,14 @@ public class ManualConfig : IConfig
         private readonly List<IColumnHidingRule> columnHidingRules = new List<IColumnHidingRule>();
 
         private List<IExporter> exporters = new List<IExporter>();
-        private List<IntegratedExport> integratedExporters = new List<IntegratedExport>();
+        private List<IntegratedExporterData> integratedExporters = new List<IntegratedExporterData>();
+
+        private IntegratedExportType integratedExporterType;
+        public IntegratedExportType IntegratedExportType => integratedExporterType;
 
         public IEnumerable<IColumnProvider> GetColumnProviders() => columnProviders;
         public IEnumerable<IExporter> GetExporters() => exporters;
-        public IEnumerable<IntegratedExport> GetIntegratedExporters() => integratedExporters;
+        public IEnumerable<IntegratedExporterData> GetIntegratedExporters() => integratedExporters;
         public IEnumerable<ILogger> GetLoggers() => loggers;
         public IEnumerable<IDiagnoser> GetDiagnosers() => diagnosers;
         public IEnumerable<IAnalyser> GetAnalysers() => analysers;
@@ -113,21 +116,6 @@ public ManualConfig WithBuildTimeout(TimeSpan buildTimeout)
             return this;
         }
 
-        public ManualConfig WithSetExporters(List<IExporter> updatedExporters)
-        {
-            exporters.Clear();
-            exporters = updatedExporters;
-            return this;
-        }
-
-        public ManualConfig WithSetIntegratedExporters(List<IntegratedExport> updatedExporters)
-        {
-            integratedExporters.Clear();
-            integratedExporters.AddRange(updatedExporters);
-            return this;
-        }
-
-
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This method will soon be removed, please start using .AddColumn() instead.")]
         public void Add(params IColumn[] newColumns) => AddColumn(newColumns);
@@ -158,6 +146,19 @@ public ManualConfig AddExporter(params IExporter[] newExporters)
             return this;
         }
 
+        public ManualConfig AddIntegratedExporter(List<IExporter>? dependencies, IExporter withExporter, IExporter exporter)
+        {
+            integratedExporters.Add(new IntegratedExporterData() { Exporter = exporter, WithExporter = withExporter, Dependencies = dependencies });
+            return this;
+        }
+
+        public ManualConfig SetIntegratedExporterType(IntegratedExportType type)
+        {
+            integratedExporterType = type;
+            return this;
+        }
+
+
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This method will soon be removed, please start using .AddLogger() instead.")]
         public void Add(params ILogger[] newLoggers) => AddLogger(newLoggers);
@@ -275,6 +276,7 @@ public void Add(IConfig config)
         {
             columnProviders.AddRange(config.GetColumnProviders());
             exporters.AddRange(config.GetExporters());
+            integratedExporters.AddRange(config.GetIntegratedExporters());
             loggers.AddRange(config.GetLoggers());
             diagnosers.AddRange(config.GetDiagnosers());
             analysers.AddRange(config.GetAnalysers());
@@ -348,5 +350,6 @@ private static TimeSpan GetBuildTimeout(TimeSpan current, TimeSpan other)
             => current == DefaultConfig.Instance.BuildTimeout
                 ? other
                 : TimeSpan.FromMilliseconds(Math.Max(current.TotalMilliseconds, other.TotalMilliseconds));
+
     }
 }
diff --git a/src/BenchmarkDotNet/Exporters/CompositeExporter.cs b/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
index 7e70a05a82..1c3ad19512 100644
--- a/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
@@ -11,12 +11,9 @@ namespace BenchmarkDotNet.Exporters
     public class CompositeExporter : IExporter
     {
         private readonly ImmutableArray<IExporter> exporters;
-        private readonly ImmutableArray<IntegratedExport> integratedExports;
 
         public CompositeExporter(ImmutableArray<IExporter> exporters) => this.exporters = exporters;
 
-        public CompositeExporter(ImmutableArray<IntegratedExport> integratedExports) => this.integratedExports = integratedExports;
-
         public string Name => nameof(CompositeExporter);
 
         public void ExportToLog(Summary summary, ILogger logger)
@@ -55,47 +52,47 @@ public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
                     return files;
                 });
             }
-            else if (integratedExports != null && integratedExports.Any())
-            {
-                return integratedExports.SelectMany(exporter =>
-                {
-                    var files = new List<string>();
-                    IEnumerable<string> dependencyFilePaths = new List<string>();
-                    try
-                    {
-                        if (exporter.Dependencies.Any())
-                        {
-                            exporter.Dependencies.ForEach(d =>
-                            {
-                                files.AddRange(d.ExportToFiles(summary, consoleLogger));
-                            });
-                        }
-                        if (exporter.WithExporter != null)
-                        {
-                            files.AddRange(exporter.WithExporter.ExportToFiles(summary, consoleLogger));
-                        }
-                        if (exporter.Exporter != null && exporter.Exporter is IntegratedExporterExtension exporterBase)
-                        {
-                            object? payload = null;
-                            switch (exporter.ExportEnum)
-                            {
-                                case IntegratedExportEnum.HtmlExporterWithRPlotExporter:
-                                    if (exporter.WithExporter is RPlotExporter rPlotExporter)
-                                    {
-                                        payload = rPlotExporter.GetExpectedPngPaths(summary, consoleLogger);
-                                    }
-                                    break;
-                            }
-                            files.AddRange(exporterBase.IntegratedExportToFiles(summary, consoleLogger, payload));
-                        }
-                    }
-                    catch (Exception e)
-                    {
-                        consoleLogger.WriteLineError(e.ToString());
-                    }
-                    return files;
-                });
-            }
+            //else if (integratedExports != null && integratedExports.Any())
+            //{
+            //    return integratedExports.SelectMany(exporter =>
+            //    {
+            //        var files = new List<string>();
+            //        IEnumerable<string> dependencyFilePaths = new List<string>();
+            //        try
+            //        {
+            //            if (exporter.Dependencies.Any())
+            //            {
+            //                exporter.Dependencies.ForEach(d =>
+            //                {
+            //                    files.AddRange(d.ExportToFiles(summary, consoleLogger));
+            //                });
+            //            }
+            //            if (exporter.WithExporter != null)
+            //            {
+            //                files.AddRange(exporter.WithExporter.ExportToFiles(summary, consoleLogger));
+            //            }
+            //            if (exporter.Exporter != null && exporter.Exporter is IntegratedExporterExtension exporterBase)
+            //            {
+            //                object? payload = null;
+            //                switch (exporter.ExportEnum)
+            //                {
+            //                    case IntegratedExporterType.HtmlExporterWithRPlotExporter:
+            //                        if (exporter.WithExporter is RPlotExporter rPlotExporter)
+            //                        {
+            //                            payload = rPlotExporter.GetExpectedPngPaths(summary, consoleLogger);
+            //                        }
+            //                        break;
+            //                }
+            //                files.AddRange(exporterBase.IntegratedExportToFiles(summary, consoleLogger, payload));
+            //            }
+            //        }
+            //        catch (Exception e)
+            //        {
+            //            consoleLogger.WriteLineError(e.ToString());
+            //        }
+            //        return files;
+            //    });
+            //}
             else
             {
                 return Array.Empty<string>();
diff --git a/src/BenchmarkDotNet/Exporters/IIntegratedExports.cs b/src/BenchmarkDotNet/Exporters/IIntegratedExports.cs
deleted file mode 100644
index bc0b1bde3d..0000000000
--- a/src/BenchmarkDotNet/Exporters/IIntegratedExports.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-using BenchmarkDotNet.Helpers;
-using BenchmarkDotNet.Loggers;
-using BenchmarkDotNet.Reports;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Text;
-
-namespace BenchmarkDotNet.Exporters
-{
-    internal interface IIntegratedExports
-    {
-        IEnumerable<IntegratedExportEnum> IntegratedExportEnums { get; set; }
-    }
-}
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExport.cs b/src/BenchmarkDotNet/Exporters/IntegratedExport.cs
deleted file mode 100644
index 40b1dce969..0000000000
--- a/src/BenchmarkDotNet/Exporters/IntegratedExport.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace BenchmarkDotNet.Exporters
-{
-    public enum IntegratedExportEnum
-    {
-        HtmlExporterWithRPlotExporter,
-    }
-
-    public class IntegratedExport
-    {
-        public IntegratedExportEnum ExportEnum { get; set; }
-        public IExporter Exporter { get; set; }
-        public IExporter WithExporter { get; set; }
-        public List<IExporter> Dependencies { get; set; }
-    }
-
-    public static class IntegratedExportersMap
-    {
-        private static readonly Dictionary<IntegratedExportEnum, List<string>> ExportTypesDictionary = new Dictionary<IntegratedExportEnum, List<string>>
-        {
-            { IntegratedExportEnum.HtmlExporterWithRPlotExporter, new List<string> { nameof(RPlotExporter), nameof(HtmlExporter) } }
-        };
-
-        public static IReadOnlyDictionary<IntegratedExportEnum, List<string>> ExportTypes => ExportTypesDictionary;
-
-        public static string[] SplitEnumByWith(IntegratedExportEnum enumValue)
-        {
-            string enumString = enumValue.ToString();
-
-            return enumString.Split(new string[] { "With" }, StringSplitOptions.None);
-        }
-    }
-}
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/CompositeIntegratedExporter.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/CompositeIntegratedExporter.cs
new file mode 100644
index 0000000000..6858ef50a3
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/CompositeIntegratedExporter.cs
@@ -0,0 +1,72 @@
+using BenchmarkDotNet.Extensions;
+using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Reports;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters.IntegratedExporter
+{
+    internal class CompositeIntegratedExporter : IExporter
+    {
+        private readonly ImmutableArray<IntegratedExporterData> exporters;
+
+        public CompositeIntegratedExporter(ImmutableArray<IntegratedExporterData> integratedExporters) => this.exporters = integratedExporters;
+
+        public string Name => nameof(CompositeExporter);
+
+        public void ExportToLog(Summary summary, ILogger logger)
+        {
+            if (summary.GetColumns().IsNullOrEmpty())
+                logger.WriteLineHint("You haven't configured any columns, your results will be empty");
+        }
+
+        public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
+        {
+            //else if (integratedExports != null && integratedExports.Any())
+            //{
+            //    return integratedExports.SelectMany(exporter =>
+            //    {
+            //        var files = new List<string>();
+            //        IEnumerable<string> dependencyFilePaths = new List<string>();
+            //        try
+            //        {
+            //            if (exporter.Dependencies.Any())
+            //            {
+            //                exporter.Dependencies.ForEach(d =>
+            //                {
+            //                    files.AddRange(d.ExportToFiles(summary, consoleLogger));
+            //                });
+            //            }
+            //            if (exporter.WithExporter != null)
+            //            {
+            //                files.AddRange(exporter.WithExporter.ExportToFiles(summary, consoleLogger));
+            //            }
+            //            if (exporter.Exporter != null && exporter.Exporter is IntegratedExporterExtension exporterBase)
+            //            {
+            //                object? payload = null;
+            //                switch (exporter.ExportEnum)
+            //                {
+            //                    case IntegratedExporterType.HtmlExporterWithRPlotExporter:
+            //                        if (exporter.WithExporter is RPlotExporter rPlotExporter)
+            //                        {
+            //                            payload = rPlotExporter.GetExpectedPngPaths(summary, consoleLogger);
+            //                        }
+            //                        break;
+            //                }
+            //                files.AddRange(exporterBase.IntegratedExportToFiles(summary, consoleLogger, payload));
+            //            }
+            //        }
+            //        catch (Exception e)
+            //        {
+            //            consoleLogger.WriteLineError(e.ToString());
+            //        }
+            //        return files;
+            //    });
+            //}
+            return Array.Empty<string>();
+        }
+    }
+}
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/IIntegratedExporter.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IIntegratedExporter.cs
new file mode 100644
index 0000000000..3038b20ed2
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IIntegratedExporter.cs
@@ -0,0 +1,17 @@
+using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Reports;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters.IntegratedExporter
+{
+    public interface IIntegratedExporter
+    {
+        string Name { get; }
+        void ExportToLog(Action callback);
+        IEnumerable<string> ExportToFiles(Func<IEnumerable<string>> callback);
+        IntegratedExportType GetIntegratedExportType();
+    }
+}
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExportType.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExportType.cs
new file mode 100644
index 0000000000..d191ef56f0
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExportType.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters.IntegratedExporter
+{
+    public enum IntegratedExportType
+    {
+        HtmlExporterWithRPlotExporter
+    }
+}
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporter.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporter.cs
new file mode 100644
index 0000000000..3e003697de
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporter.cs
@@ -0,0 +1,34 @@
+using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Reports;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters.IntegratedExporter
+{
+    public class IntegratedExporter : IIntegratedExporter
+    {
+        private readonly IntegratedExportType integratedExporterTypes;
+        public IntegratedExporter(IntegratedExportType integratedExporterTypes)
+        {
+            this.integratedExporterTypes = integratedExporterTypes;
+        }
+        public string Name => nameof(IntegratedExporter);
+
+        public IEnumerable<string> ExportToFiles(Func<IEnumerable<string>> callback)
+        {
+            var result = callback();
+            return result;
+        }
+
+        public void ExportToLog(Action callback)
+        {
+            callback();
+        }
+
+        public IntegratedExportType GetIntegratedExportType() => integratedExporterTypes;
+    }
+
+
+}
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterData.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterData.cs
new file mode 100644
index 0000000000..16f0e54a09
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterData.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters.IntegratedExporter
+{
+    public class IntegratedExporterData
+    {
+        public IExporter Exporter { get; set; }
+        public IExporter WithExporter { get; set; }
+        public List<IExporter>? Dependencies { get; set; }
+    }
+}
diff --git a/src/BenchmarkDotNet/Exporters/RPlotExporter.cs b/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
index 4ea9790cb2..2f076d0527 100644
--- a/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
@@ -14,13 +14,8 @@
 
 namespace BenchmarkDotNet.Exporters
 {
-    public class RPlotExporter : IExporter, IExporterDependencies, IIntegratedExports
+    public class RPlotExporter : IExporter, IExporterDependencies
     {
-        public RPlotExporter(IntegratedExportEnum[] IntegratedExportEnums = null)
-        {
-            this.IntegratedExportEnums = IntegratedExportEnums;
-        }
-
         public static readonly IExporter Default = new RPlotExporter();
         public string Name => nameof(RPlotExporter);
 
@@ -32,8 +27,6 @@ public IEnumerable<IExporter> Dependencies
             get { yield return CsvMeasurementsExporter.Default; }
         }
 
-        public IEnumerable<IntegratedExportEnum> IntegratedExportEnums { get; set; }
-
         public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
         {
             const string scriptFileName = "BuildPlots.R";
diff --git a/src/BenchmarkDotNet/Running/BenchmarkConverter.cs b/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
index ee8d84cc02..4db3db43c3 100644
--- a/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
+++ b/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
@@ -8,6 +8,7 @@
 using BenchmarkDotNet.Code;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Order;
@@ -89,20 +90,46 @@ private static ImmutableConfig GetFullTypeConfig(Type type, IConfig? config)
         {
             config = config ?? DefaultConfig.Instance;
 
+
             var typeAttributes = type.GetCustomAttributes(true).OfType<IConfigSource>();
             var assemblyAttributes = type.Assembly.GetCustomAttributes().OfType<IConfigSource>();
 
             foreach (var configFromAttribute in assemblyAttributes.Concat(typeAttributes))
-                config = ManualConfig.Union(config, configFromAttribute.Config);
+            {
+                if (configFromAttribute.GetType().Name == "IntegratedExporterAttribute" && configFromAttribute.Config is ManualConfig manualConfig)
+                {
+                    IntegratedExportType integratedExportType = manualConfig.IntegratedExportType;
+                    bool isExported = TryGetIntegratedExportersByType(integratedExportType, out List<IExporter>? dependencies, out IExporter exporter, out IExporter withExporter);
+                    if (!isExported) continue;
+                    config = ManualConfig.Union(config, ManualConfig.CreateEmpty().AddIntegratedExporter(dependencies: dependencies, withExporter: withExporter, exporter: exporter));
+                }
+                else
+                {
+                    config = ManualConfig.Union(config, configFromAttribute.Config);
+                }
+            }
 
-            // Check for integrated exporters
-            //IReadOnlyCollection<IntegratedExportEnum> integrationExportEnums = ExtractIntegrationExportEnums(config.GetExporters());
-            //if (integrationExportEnums.Any())
-            //    config = ProcessIntegratedConfiguration(config, integrationExportEnums);
 
             return ImmutableConfigBuilder.Create(config);
         }
 
+        private static bool TryGetIntegratedExportersByType(IntegratedExportType type, out List<IExporter>? dependencies, out IExporter exporter, out IExporter withExporter)
+        {
+            switch (type)
+            {
+                case IntegratedExportType.HtmlExporterWithRPlotExporter:
+                    exporter = HtmlExporter.Default;
+                    withExporter = RPlotExporter.Default;
+                    dependencies = (withExporter is IExporterDependencies exporterDependencies) ? exporterDependencies.Dependencies.ToList() : null;
+                    return true;
+                default:
+                    exporter = null;
+                    withExporter = null;
+                    dependencies = null;
+                    return false;
+            }
+        }
+
         private static ImmutableConfig GetFullMethodConfig(MethodInfo method, ImmutableConfig typeConfig)
         {
             var methodAttributes = method.GetCustomAttributes(true).OfType<IConfigSource>();
@@ -358,39 +385,5 @@ private static object[] GetAllValidValues(Type parameterType)
 
             return new object[] { Activator.CreateInstance(parameterType) };
         }
-
-        private static IReadOnlyCollection<IntegratedExportEnum> ExtractIntegrationExportEnums(IEnumerable<IExporter> exporters)
-        {
-            return exporters
-                    .OfType<IIntegratedExports>()
-                    .Where(export => export.IntegratedExportEnums.Any())
-                    .SelectMany(export => export.IntegratedExportEnums)
-                    .ToList();
-        }
-
-        private static IConfig ProcessIntegratedConfiguration(IConfig config, IEnumerable<IntegratedExportEnum> integrationExportEnums)
-        {
-            var allExporters = config.GetExporters().ToList();
-            var integratedExports = integrationExportEnums.Select(exportEnum =>
-            {
-                var exporterTypesStr = IntegratedExportersMap.SplitEnumByWith(exportEnum);
-                return new IntegratedExport
-                {
-                    ExportEnum = exportEnum,
-                    Exporter = allExporters.FirstOrDefault(e => exporterTypesStr[0] == e.Name),
-                    WithExporter = allExporters.FirstOrDefault(e => exporterTypesStr[1] == e.Name)
-                };
-            }).ToList();
-
-            var distinctExporters = allExporters
-                    .Where(exporter => !integratedExports
-                    .Any(integrated => integrated.Exporter.Name == exporter.Name ||
-                                     integrated.WithExporter.Name == exporter.Name))
-                .ToList();
-
-            return config
-                .WithSetExporters(distinctExporters)
-                .WithSetIntegratedExporters(integratedExports);
-        }
     }
 }

From bb5e2781d08eafb70bd63aee92d54bb0191a84d5 Mon Sep 17 00:00:00 2001
From: Avishai Dotan <108017307+AvishaiDotan@users.noreply.github.com>
Date: Sun, 19 Jan 2025 21:32:24 +0200
Subject: [PATCH 4/5] convert logic to IntegratedExporter

---
 .../Configs/ImmutableConfigBuilder.cs         | 35 +++++--
 .../Exporters/CompositeExporter.cs            | 70 +++-----------
 src/BenchmarkDotNet/Exporters/HtmlExporter.cs |  3 +-
 .../CompositeIntegratedExporter.cs            | 94 ++++++++++---------
 .../IntegratedExporterData.cs                 |  1 +
 .../IntegratedExporterExtension.cs            |  2 +-
 .../Running/BenchmarkRunnerClean.cs           | 14 +--
 7 files changed, 102 insertions(+), 117 deletions(-)
 rename src/BenchmarkDotNet/Exporters/{ => IntegratedExporter}/IntegratedExporterExtension.cs (96%)

diff --git a/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs b/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
index 0e00fbeaa1..126d45410e 100644
--- a/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
+++ b/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Reflection;
 using BenchmarkDotNet.Analysers;
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.Exporters;
@@ -46,15 +47,37 @@ public static ImmutableConfig Create(IConfig source)
             var uniqueDiagnosers = GetDiagnosers(source.GetDiagnosers(), uniqueHardwareCounters);
 
             var integratedExporters = source?.GetIntegratedExporters();
+            IEnumerable<IExporter>? distinctExporters = null;
             if (integratedExporters is not null && integratedExporters.Count() > 0)
             {
-                var distinctExporters = source.GetExporters().DistinctBy(e =>
+                var exporters = source.GetExporters();
+                foreach (var e in exporters)
                 {
-                    bool hasIntegratedExporter = source
-                })
+                    if (integratedExporters.Any(ie => ie.Exporter.GetType() == e.GetType()))
+                    {
+                        continue;
+                    }
+                    if (integratedExporters.Any(ie => ie.WithExporter.GetType() == e.GetType()))
+                    {
+                        continue;
+                    }
+                    if (integratedExporters.Any(ie => ie?.Dependencies?.Any(d => d.GetType() == e.GetType()) ?? false))
+                    {
+                        continue;
+                    }
+
+                    if (distinctExporters is null)
+                    {
+                        distinctExporters = new List<IExporter> { e };
+                    }
+                    else
+                    {
+                        ((List<IExporter>)distinctExporters).Add(e);
+                    }
+                }
             }
 
-            var allExporters = GetExporters(source.GetExporters(), uniqueDiagnosers, configAnalyse);
+            var allUniqueExporters = GetExporters(distinctExporters, uniqueDiagnosers, configAnalyse);
 
             // Check for integrated exporters
             var uniqueAnalyzers = GetAnalysers(source.GetAnalysers(), uniqueDiagnosers);
@@ -73,8 +96,8 @@ public static ImmutableConfig Create(IConfig source)
                 uniqueLoggers,
                 uniqueHardwareCounters,
                 uniqueDiagnosers,
-                allExporters,
-                new ImmutableArray<IntegratedExporterData>(),
+                allUniqueExporters,
+                integratedExporters?.ToImmutableArray() ?? new ImmutableArray<IntegratedExporterData>(),
                 uniqueAnalyzers,
                 uniqueValidators,
                 uniqueFilters,
diff --git a/src/BenchmarkDotNet/Exporters/CompositeExporter.cs b/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
index 1c3ad19512..f7da35e021 100644
--- a/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
@@ -36,67 +36,19 @@ public void ExportToLog(Summary summary, ILogger logger)
 
         public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
         {
-            if (exporters != null && exporters.Any())
+            return exporters.SelectMany(exporter =>
             {
-                return exporters.SelectMany(exporter =>
+                var files = new List<string>();
+                try
                 {
-                    var files = new List<string>();
-                    try
-                    {
-                        files.AddRange(exporter.ExportToFiles(summary, consoleLogger));
-                    }
-                    catch (Exception e)
-                    {
-                        consoleLogger.WriteLineError(e.ToString());
-                    }
-                    return files;
-                });
-            }
-            //else if (integratedExports != null && integratedExports.Any())
-            //{
-            //    return integratedExports.SelectMany(exporter =>
-            //    {
-            //        var files = new List<string>();
-            //        IEnumerable<string> dependencyFilePaths = new List<string>();
-            //        try
-            //        {
-            //            if (exporter.Dependencies.Any())
-            //            {
-            //                exporter.Dependencies.ForEach(d =>
-            //                {
-            //                    files.AddRange(d.ExportToFiles(summary, consoleLogger));
-            //                });
-            //            }
-            //            if (exporter.WithExporter != null)
-            //            {
-            //                files.AddRange(exporter.WithExporter.ExportToFiles(summary, consoleLogger));
-            //            }
-            //            if (exporter.Exporter != null && exporter.Exporter is IntegratedExporterExtension exporterBase)
-            //            {
-            //                object? payload = null;
-            //                switch (exporter.ExportEnum)
-            //                {
-            //                    case IntegratedExporterType.HtmlExporterWithRPlotExporter:
-            //                        if (exporter.WithExporter is RPlotExporter rPlotExporter)
-            //                        {
-            //                            payload = rPlotExporter.GetExpectedPngPaths(summary, consoleLogger);
-            //                        }
-            //                        break;
-            //                }
-            //                files.AddRange(exporterBase.IntegratedExportToFiles(summary, consoleLogger, payload));
-            //            }
-            //        }
-            //        catch (Exception e)
-            //        {
-            //            consoleLogger.WriteLineError(e.ToString());
-            //        }
-            //        return files;
-            //    });
-            //}
-            else
-            {
-                return Array.Empty<string>();
-            }
+                    files.AddRange(exporter.ExportToFiles(summary, consoleLogger));
+                }
+                catch (Exception e)
+                {
+                    consoleLogger.WriteLineError(e.ToString());
+                }
+                return files;
+            });
         }
     }
 }
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Exporters/HtmlExporter.cs b/src/BenchmarkDotNet/Exporters/HtmlExporter.cs
index eb290c87a3..d240c8964e 100644
--- a/src/BenchmarkDotNet/Exporters/HtmlExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/HtmlExporter.cs
@@ -1,4 +1,5 @@
-using BenchmarkDotNet.Extensions;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
+using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Reports;
 using System;
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/CompositeIntegratedExporter.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/CompositeIntegratedExporter.cs
index 6858ef50a3..c43d40afb4 100644
--- a/src/BenchmarkDotNet/Exporters/IntegratedExporter/CompositeIntegratedExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/CompositeIntegratedExporter.cs
@@ -21,52 +21,60 @@ public void ExportToLog(Summary summary, ILogger logger)
         {
             if (summary.GetColumns().IsNullOrEmpty())
                 logger.WriteLineHint("You haven't configured any columns, your results will be empty");
+
+            foreach (var exporter in exporters)
+            {
+                try
+                {
+
+                    foreach (var dependencyExporter in exporter?.Dependencies ?? new List<IExporter>())
+                    {
+                        dependencyExporter.ExportToLog(summary, logger);
+                    }
+                    exporter.WithExporter.ExportToLog(summary, logger);
+                    exporter.Exporter.ExportToLog(summary, logger);
+                }
+                catch (Exception e)
+                {
+                    logger.WriteLineError(e.ToString());
+                }
+            }
         }
 
         public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
         {
-            //else if (integratedExports != null && integratedExports.Any())
-            //{
-            //    return integratedExports.SelectMany(exporter =>
-            //    {
-            //        var files = new List<string>();
-            //        IEnumerable<string> dependencyFilePaths = new List<string>();
-            //        try
-            //        {
-            //            if (exporter.Dependencies.Any())
-            //            {
-            //                exporter.Dependencies.ForEach(d =>
-            //                {
-            //                    files.AddRange(d.ExportToFiles(summary, consoleLogger));
-            //                });
-            //            }
-            //            if (exporter.WithExporter != null)
-            //            {
-            //                files.AddRange(exporter.WithExporter.ExportToFiles(summary, consoleLogger));
-            //            }
-            //            if (exporter.Exporter != null && exporter.Exporter is IntegratedExporterExtension exporterBase)
-            //            {
-            //                object? payload = null;
-            //                switch (exporter.ExportEnum)
-            //                {
-            //                    case IntegratedExporterType.HtmlExporterWithRPlotExporter:
-            //                        if (exporter.WithExporter is RPlotExporter rPlotExporter)
-            //                        {
-            //                            payload = rPlotExporter.GetExpectedPngPaths(summary, consoleLogger);
-            //                        }
-            //                        break;
-            //                }
-            //                files.AddRange(exporterBase.IntegratedExportToFiles(summary, consoleLogger, payload));
-            //            }
-            //        }
-            //        catch (Exception e)
-            //        {
-            //            consoleLogger.WriteLineError(e.ToString());
-            //        }
-            //        return files;
-            //    });
-            //}
-            return Array.Empty<string>();
+            return exporters.SelectMany(exporter =>
+            {
+                var files = new List<string>();
+                try
+                {
+                    var dependencyFiles = (exporter?.Dependencies ?? new List<IExporter>()).SelectMany(dependencyExporter => dependencyExporter.ExportToFiles(summary, consoleLogger));
+                    files.AddRange(dependencyFiles);
+                    foreach (var file in exporter.WithExporter.ExportToFiles(summary, consoleLogger))
+                    {
+                        files.Add(file);
+                    }
+                    if (exporter.Exporter != null && exporter.Exporter is IntegratedExporterExtension exporterBase)
+                    {
+                        object? payload = null;
+                        switch (exporter.ExporterType)
+                        {
+                            case IntegratedExportType.HtmlExporterWithRPlotExporter:
+                                if (exporter.WithExporter is RPlotExporter rPlotExporter)
+                                {
+                                    payload = rPlotExporter.GetExpectedPngPaths(summary, consoleLogger);
+                                }
+                                break;
+                        }
+                        files.AddRange(exporterBase.IntegratedExportToFiles(summary, consoleLogger, payload));
+                    }
+                }
+                catch (Exception e)
+                {
+                    consoleLogger.WriteLineError(e.ToString());
+                }
+                return files;
+            });
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterData.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterData.cs
index 16f0e54a09..29d84c3f0f 100644
--- a/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterData.cs
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterData.cs
@@ -9,5 +9,6 @@ public class IntegratedExporterData
         public IExporter Exporter { get; set; }
         public IExporter WithExporter { get; set; }
         public List<IExporter>? Dependencies { get; set; }
+        public IntegratedExportType ExporterType { get; set; }
     }
 }
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporterExtension.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterExtension.cs
similarity index 96%
rename from src/BenchmarkDotNet/Exporters/IntegratedExporterExtension.cs
rename to src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterExtension.cs
index 81e8952e0c..416f7eb96e 100644
--- a/src/BenchmarkDotNet/Exporters/IntegratedExporterExtension.cs
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterExtension.cs
@@ -5,7 +5,7 @@
 using System.IO;
 using System.Text;
 
-namespace BenchmarkDotNet.Exporters
+namespace BenchmarkDotNet.Exporters.IntegratedExporter
 {
     public abstract class IntegratedExporterExtension : ExporterBase
     {
diff --git a/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs b/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
index 454cc12427..467a9772dd 100644
--- a/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
+++ b/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
@@ -297,13 +297,13 @@ private static void PrintSummary(ILogger logger, ImmutableConfig config, Summary
                 logger.WriteLineInfo($"  {file.GetBaseName(currentDirectory)}");
             }
 
-            //if (config.GetIntegratedExports().Any())
-            //{
-            //    foreach (string file in config.GetCompositeIntegratedExporter().ExportToFiles(summary, logger))
-            //    {
-            //        logger.WriteLineInfo($"  {file.GetBaseName(currentDirectory)}");
-            //    }
-            //}
+            if (config.GetIntegratedExporters().Any())
+            {
+                foreach (string file in config.GetCompositeIntegratedExporter().ExportToFiles(summary, logger))
+                {
+                    logger.WriteLineInfo($"  {file.GetBaseName(currentDirectory)}");
+                }
+            }
 
 
             logger.WriteLine();

From d225b9635e09d6b5320db5ac3603df0b6309c975 Mon Sep 17 00:00:00 2001
From: Avishai Dotan <108017307+AvishaiDotan@users.noreply.github.com>
Date: Fri, 24 Jan 2025 13:47:34 +0200
Subject: [PATCH 5/5] Fix config error

---
 samples/BenchmarkDotNet.Samples/Program.cs    |  3 +-
 .../Configs/ImmutableConfigBuilder.cs         | 39 +++++++------------
 .../Running/BenchmarkConverter.cs             |  6 +--
 .../Running/BenchmarkRunnerClean.cs           |  3 +-
 4 files changed, 19 insertions(+), 32 deletions(-)

diff --git a/samples/BenchmarkDotNet.Samples/Program.cs b/samples/BenchmarkDotNet.Samples/Program.cs
index 440e27b4b8..71daa668ba 100644
--- a/samples/BenchmarkDotNet.Samples/Program.cs
+++ b/samples/BenchmarkDotNet.Samples/Program.cs
@@ -4,7 +4,6 @@ namespace BenchmarkDotNet.Samples
 {
     public class Program
     {
-        //public static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
-        public static void Main(string[] args) => BenchmarkRunner.Run<IntroIntegratedExporter>();
+        public static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
     }
 }
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs b/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
index 126d45410e..0e0022cfe3 100644
--- a/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
+++ b/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
@@ -48,33 +48,20 @@ public static ImmutableConfig Create(IConfig source)
 
             var integratedExporters = source?.GetIntegratedExporters();
             IEnumerable<IExporter>? distinctExporters = null;
-            if (integratedExporters is not null && integratedExporters.Count() > 0)
-            {
-                var exporters = source.GetExporters();
-                foreach (var e in exporters)
-                {
-                    if (integratedExporters.Any(ie => ie.Exporter.GetType() == e.GetType()))
-                    {
-                        continue;
-                    }
-                    if (integratedExporters.Any(ie => ie.WithExporter.GetType() == e.GetType()))
-                    {
-                        continue;
-                    }
-                    if (integratedExporters.Any(ie => ie?.Dependencies?.Any(d => d.GetType() == e.GetType()) ?? false))
-                    {
-                        continue;
-                    }
 
-                    if (distinctExporters is null)
-                    {
-                        distinctExporters = new List<IExporter> { e };
-                    }
-                    else
-                    {
-                        ((List<IExporter>)distinctExporters).Add(e);
-                    }
-                }
+            if (integratedExporters?.Any() == true)
+            {
+                distinctExporters = source.GetExporters()
+                    .Where(e =>
+                        !integratedExporters.Any(ie =>
+                            ie.Exporter.GetType() == e.GetType() ||
+                            ie.WithExporter.GetType() == e.GetType() ||
+                            ie.Dependencies?.Any(d => d.GetType() == e.GetType()) == true))
+                    .ToList();
+            }
+            else
+            {
+                distinctExporters = source.GetExporters();
             }
 
             var allUniqueExporters = GetExporters(distinctExporters, uniqueDiagnosers, configAnalyse);
diff --git a/src/BenchmarkDotNet/Running/BenchmarkConverter.cs b/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
index 4db3db43c3..22221d9828 100644
--- a/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
+++ b/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
@@ -99,9 +99,9 @@ private static ImmutableConfig GetFullTypeConfig(Type type, IConfig? config)
                 if (configFromAttribute.GetType().Name == "IntegratedExporterAttribute" && configFromAttribute.Config is ManualConfig manualConfig)
                 {
                     IntegratedExportType integratedExportType = manualConfig.IntegratedExportType;
-                    bool isExported = TryGetIntegratedExportersByType(integratedExportType, out List<IExporter>? dependencies, out IExporter exporter, out IExporter withExporter);
-                    if (!isExported) continue;
-                    config = ManualConfig.Union(config, ManualConfig.CreateEmpty().AddIntegratedExporter(dependencies: dependencies, withExporter: withExporter, exporter: exporter));
+                    bool success = TryGetIntegratedExportersByType(integratedExportType, out List<IExporter>? dependencies, out IExporter exporter, out IExporter withExporter);
+                    if (!success || withExporter == null || exporter == null) continue;
+                    config = ManualConfig.Union(config, ManualConfig.CreateEmpty().AddIntegratedExporter(dependencies, withExporter, exporter));
                 }
                 else
                 {
diff --git a/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs b/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
index 467a9772dd..54e0f1d1e7 100644
--- a/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
+++ b/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
@@ -14,6 +14,7 @@
 using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Jobs;
@@ -297,7 +298,7 @@ private static void PrintSummary(ILogger logger, ImmutableConfig config, Summary
                 logger.WriteLineInfo($"  {file.GetBaseName(currentDirectory)}");
             }
 
-            if (config.GetIntegratedExporters().Any())
+            if ((config?.GetIntegratedExporters() ?? new List<IntegratedExporterData>()).Any())
             {
                 foreach (string file in config.GetCompositeIntegratedExporter().ExportToFiles(summary, logger))
                 {