docs: private static void handleProperty(final AttributeDefinition attribute, final OperationContext context, final ModelNode model,
                                         final LogContextConfiguration logContextConfiguration, final HandlerConfiguration configuration, final boolean resolveValue)
              throws OperationFailedException {
  
          if (attribute.getName().equals(ENABLED.getName())) {
              final boolean value = ((resolveValue ? ENABLED.resolveModelAttribute(context, model).asBoolean() : model.asBoolean()));
              if (value) {
                  enableHandler(logContextConfiguration, configuration.getName());
              } else {
                  disableHandler(logContextConfiguration, configuration.getName());
              }
          } else if (attribute.getName().equals(ENCODING.getName())) {
              final String resolvedValue = (resolveValue ? ENCODING.resolvePropertyValue(context, model) : model.isDefined() ? model.asString() : null);
              configuration.setEncoding(resolvedValue);
          } else if (attribute.getName().equals(FORMATTER.getName())) {
              // The handler name will be used for the name of a formatter for the formatter attribute
              final String defaultFormatterName = configuration.getName() + PatternFormatterResourceDefinition.DEFAULT_FORMATTER_SUFFIX;
              // Get the current model and check for a defined named-formatter attribute
              final Resource resource = context.readResource(PathAddress.EMPTY_ADDRESS);
              final ModelNode m = resource.getModel();
              if (m.hasDefined(NAMED_FORMATTER.getName())) {
                  // If a named-formatter exists in the model and a formatter already exists with the name of the handler
                  // remove the formatter
                  if (logContextConfiguration.getFormatterNames().contains(defaultFormatterName)) {
                      logContextConfiguration.removeFormatterConfiguration(defaultFormatterName);
                  }
              } else {
                  // Create a formatter based on the handlers name
                  final FormatterConfiguration fmtConfig;
                  if (logContextConfiguration.getFormatterNames().contains(defaultFormatterName)) {
                      fmtConfig = logContextConfiguration.getFormatterConfiguration(defaultFormatterName);
                  } else {
                      fmtConfig = logContextConfiguration.addFormatterConfiguration(null, PatternFormatter.class.getName(), defaultFormatterName, PATTERN.getPropertyName());
                  }
                  final String resolvedValue = (resolveValue ? FORMATTER.resolvePropertyValue(context, model) : model.asString());
                  fmtConfig.setPropertyValueString(PATTERN.getPropertyName(), resolvedValue);
                  configuration.setFormatterName(defaultFormatterName);
              }
          } else if (attribute.getName().equals(NAMED_FORMATTER.getName())) {
              // The name of the handler will be used for a "formatter" if the named-formatter is not defined
              final String handlerName = configuration.getName();
              final String defaultFormatterName = handlerName + PatternFormatterResourceDefinition.DEFAULT_FORMATTER_SUFFIX;
              final ModelNode valueNode = (resolveValue ? NAMED_FORMATTER.resolveModelAttribute(context, model) : model);
              // Set the formatter if the value is defined
              if (valueNode.isDefined()) {
                  final String resolvedValue = valueNode.asString();
                  configuration.setFormatterName(resolvedValue);
                  // If the formatter was previously defined by the formatter attribute, remove the formatter
                  if (logContextConfiguration.getFormatterNames().contains(defaultFormatterName)) {
                      logContextConfiguration.removeFormatterConfiguration(defaultFormatterName);
                  }
              } else if (configuration.getClassName().equals(SyslogHandler.class.getName())) {
                  // The value shouldn't be defined so we want to remove the current formatter, however a null formatter
                  // is not allowed in a java.util.logging.Handler. Therefore we must configure a formatter of some kind.
                  // We'll skip the config step on this and set the handler manually. This allows the formatter
                  // configuration not to be persisted. By default the SyslogHandler will use
                  // ExtLogRecord.getFormattedMessage() to get the message which the %s pattern should duplicate.
                  final Handler instance = configuration.getInstance();
                  if (instance != null) {
                      instance.setFormatter(new PatternFormatter("%s"));
                  }
              } else {
                  // If the named-formatter was undefined we need to create a formatter based on the formatter attribute
                  final FormatterConfiguration fmtConfig;
                  if (logContextConfiguration.getFormatterNames().contains(defaultFormatterName)) {
                      fmtConfig = logContextConfiguration.getFormatterConfiguration(defaultFormatterName);
                  } else {
                      fmtConfig = logContextConfiguration.addFormatterConfiguration(null, PatternFormatter.class.getName(), defaultFormatterName, PATTERN.getPropertyName());
                  }
                  // Get the current model and set the value of the formatter based on the formatter attribute
                  final Resource resource = context.readResource(PathAddress.EMPTY_ADDRESS);
                  fmtConfig.setPropertyValueString(PATTERN.getPropertyName(), FORMATTER.resolvePropertyValue(context, resource.getModel()));
                  configuration.setFormatterName(defaultFormatterName);
              }
          } else if (attribute.getName().equals(FILTER_SPEC.getName())) {
              final ModelNode valueNode = (resolveValue ? FILTER_SPEC.resolveModelAttribute(context, model) : model);
              final String resolvedValue = (valueNode.isDefined() ? valueNode.asString() : null);
              configuration.setFilter(resolvedValue);
          } else if (attribute.getName().equals(LEVEL.getName())) {
              final String resolvedValue = (resolveValue ? LEVEL.resolvePropertyValue(context, model) : LEVEL.resolver().resolveValue(context, model));
              configuration.setLevel(resolvedValue);
          } else if (attribute.getName().equals(SUBHANDLERS.getName())) {
              final Collection<String> resolvedValue = (resolveValue ? SUBHANDLERS.resolvePropertyValue(context, model) : SUBHANDLERS.resolver().resolveValue(context, model));
              if (resolvedValue.contains(configuration.getName())) {
                  throw createOperationFailure(LoggingLogger.ROOT_LOGGER.cannotAddHandlerToSelf(configuration.getName()));
              }
              configuration.setHandlerNames(resolvedValue);
          } else if (attribute.getName().equals(HANDLER_NAME.getName())) {
              // no-op just ignore the name attribute
          } else if (attribute.getName().equals(PROPERTIES.getName())) {
              final PropertyConfigurable propertyConfigurable;
              // A POJO configuration will have the same name as the handler
              final PojoConfiguration pojoConfiguration = logContextConfiguration.getPojoConfiguration(configuration.getName());
              if (pojoConfiguration == null) {
                  propertyConfigurable = configuration;
              } else {
                  propertyConfigurable = pojoConfiguration;
                  // A log4j appender may be an OptionHandler which requires the invocation of activateOptions(). Setting
                  // a dummy property on the Log4jAppenderHandler is required to invoke this method as all properties are
                  // set on the POJO which is the actual appender
                  configuration.setPropertyValueString(Log4jAppenderHandler.ACTIVATOR_PROPERTY_METHOD_NAME, "");
              }
              // Should be safe here to only process defined properties. The write-attribute handler handles removing
              // undefined properties
              if (model.hasDefined(PROPERTIES.getName())) {
                  final ModelNode resolvedValue = (resolveValue ? PROPERTIES.resolveModelAttribute(context, model) : model);
                  for (Property property : resolvedValue.asPropertyList()) {
                      propertyConfigurable.setPropertyValueString(property.getName(), property.getValue().asString());
                  }
              }
          } else {
              if (attribute instanceof ConfigurationProperty) {
                  @SuppressWarnings("unchecked") final ConfigurationProperty<String> configurationProperty = (ConfigurationProperty<String>) attribute;
                  if (resolveValue) {
                      configurationProperty.setPropertyValue(context, model, configuration);
                  } else {
                      // Get the resolver
                      final ModelNodeResolver<String> resolver = configurationProperty.resolver();
                      // Resolve the value
                      final String resolvedValue = (resolver == null ? (model.isDefined() ? model.asString() : null) : resolver.resolveValue(context, model));
                      if (resolvedValue == null) {
                          // The value must be set to null and then the property removed,
                          // Note that primitive attributes should use a default value as null is invalid
                          configuration.setPropertyValueString(configurationProperty.getPropertyName(), null);
                          configuration.removeProperty(configurationProperty.getPropertyName());
                      } else {
                          // Set the string value
                          configuration.setPropertyValueString(configurationProperty.getPropertyName(), resolvedValue);
                      }
                  }
              } else {
                  LoggingLogger.ROOT_LOGGER.invalidPropertyAttribute(attribute.getName());
              }
          }
      }