public void Process()

in src/StructuredLogger/Construction/MessageProcessor.cs [25:142]
100 lines of code
22 McCabe index (conditional complexity)

        public void Process(BuildMessageEventArgs args)
        {
            if (args == null)
            {
                return;
            }

            if (args is TaskParameterEventArgs taskParameter)
            {
                ProcessTaskParameter(taskParameter);
                return;
            }
            else if (args is ProjectImportedEventArgs projectImported)
            {
                ProcessProjectImported(projectImported);
                return;
            }

            var message = args.Message;
            if (string.IsNullOrEmpty(message))
            {
                return;
            }

            var buildEventContext = args.BuildEventContext;
            if (buildEventContext != null && buildEventContext.TaskId != BuildEventContext.InvalidTaskId)
            {
                if (message.StartsWith(Strings.OutputItemsMessagePrefix, StringComparison.Ordinal))
                {
                    var task = GetTask(args);

                    //this.construction.Build.Statistics.ReportOutputItemMessage(task, message);

                    var folder = task.GetOrCreateNodeWithName<Folder>(Strings.OutputItems);
                    var parameter = ItemGroupParser.ParsePropertyOrItemList(message, Strings.OutputItemsMessagePrefix, stringTable, isOutputItem: true);
                    folder.AddChild(parameter);
                    return;
                }

                if (message.StartsWith(Strings.OutputPropertyMessagePrefix, StringComparison.Ordinal))
                {
                    var task = GetTask(args);
                    var folder = task.GetOrCreateNodeWithName<Folder>(Strings.OutputProperties);
                    var parameter = ItemGroupParser.ParsePropertyOrItemList(message, Strings.OutputPropertyMessagePrefix, stringTable);
                    folder.AddChild(parameter);
                    return;
                }

                if (message.StartsWith(Strings.TaskParameterMessagePrefix, StringComparison.Ordinal))
                {
                    var task = GetTask(args);
                    if (IgnoreParameters(task))
                    {
                        return;
                    }

                    //this.construction.Build.Statistics.ReportTaskParameterMessage(task, message);

                    var folder = task.GetOrCreateNodeWithName<Folder>(Strings.Parameters);
                    var parameter = ItemGroupParser.ParsePropertyOrItemList(message, Strings.TaskParameterMessagePrefix, stringTable);
                    folder.AddChild(parameter);
                    return;
                }

                if (args is TaskCommandLineEventArgs taskArgs)
                {
                    if (AddCommandLine(taskArgs))
                    {
                        return;
                    }
                }
            }
            else if (buildEventContext != null && buildEventContext.TargetId != BuildEventContext.InvalidTargetId)
            {
                if (message.StartsWith(Strings.ItemGroupIncludeMessagePrefix, StringComparison.Ordinal))
                {
                    AddItemGroup(args, message, Strings.ItemGroupIncludeMessagePrefix, new AddItem());
                    return;
                }

                if (message.StartsWith(Strings.ItemGroupRemoveMessagePrefix, StringComparison.Ordinal))
                {
                    AddItemGroup(args, message, Strings.ItemGroupRemoveMessagePrefix, new RemoveItem());
                    return;
                }

                if (message.StartsWith(Strings.PropertyGroupMessagePrefix, StringComparison.Ordinal))
                {
                    AddPropertyGroup(args, message, Strings.PropertyGroupMessagePrefix);
                    return;
                }

                // A task from assembly message (parses out the task name and assembly path).
                var match = Strings.UsingTask(message);
                if (match.Success)
                {
                    construction.SetTaskAssembly(
                        Intern(match.Groups["task"].Value),
                        Intern(match.Groups["assembly"].Value));
                    return;
                }
            }
            else if (buildEventContext != null && buildEventContext.EvaluationId != BuildEventContext.InvalidEvaluationId)
            {
            }
            else
            {
                if (args.SenderName == "BinaryLogger")
                {
                    var parameter = ItemGroupParser.ParsePropertyOrItemList(message, string.Empty, stringTable);
                    construction.Build.AddChild(parameter);
                    return;
                }
            }

            // Just the generic log message or something we currently don't handle in the object model.
            AddMessage(args, message);
        }