// User has one `Account` (has one), many `Pets` (has many) and `Toys` (has many - polymorphic)
// He works in a Company (belongs to), he has a Manager (belongs to - single-table), and also managed a Team (has many - single-table)
// He speaks many languages (many to many) and has many friends (many to many - single-table)
// His pet also has one Toy (has one - polymorphic)
// NamedPet is a reference to a named `Pet` (has one)
type User struct {
	gorm.Model

			}
		case "av":
			z.Avg, err = dc.ReadFloat64()
			if err != nil {
				err = msgp.WrapError(err, "Avg")
				return
			}
		case "p":
			z.Peak, err = dc.ReadFloat64()
			if err != nil {
				err = msgp.WrapError(err, "Peak")
				return
			}
		case "n":
			z.N, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "N")
				return
			}
		default:

	if len(qs.XferStats) > 0 {
		tots := qs.XferStats[Total]
		m.Set(replicationAverageDataTransferRate, tots.Avg)
		m.Set(replicationCurrentDataTransferRate, tots.Curr)
		m.Set(replicationMaxDataTransferRate, tots.Peak)
	}
	m.Set(replicationRecentBacklogCount, float64(qs.MRFStats.LastFailedCount))

	return nil

        final JvmThreadsObj jvmThreadsObj = new JvmThreadsObj();
        jvmObj.threads = jvmThreadsObj;
        jvmThreadsObj.count = threads.getCount();
        jvmThreadsObj.peak = threads.getPeakCount();
        final Classes classes = jvmStats.getClasses();
        final JvmClassesObj jvmClassesObj = new JvmClassesObj();
        jvmObj.classes = jvmClassesObj;

our General Public Licenses are intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for

					throughputHighestGet = totalGet
				}
				sendResult()
				break
			}

			// We break if we did not see 2.5% growth rate in total GET
			// requests, we have reached our peak at this point.
			doBreak := float64(totalGet-throughputHighestGet)/float64(totalGet) < 0.025

			throughputHighestGet = totalGet
			throughputHighestResults = results
			throughputHighestPut = totalPut

        buf.append("},");
        final Threads threads = jvmStats.getThreads();
        buf.append("\"threads\":{");
        append(buf, "count", () -> threads.getCount()).append(',');
        append(buf, "peak", () -> threads.getPeakCount());
        buf.append("},");
        final Classes classes = jvmStats.getClasses();
        buf.append("\"classes\":{");

			metric.LastOnline = epHealth.lastOnline
			metric.Online = epHealth.Online
			metric.Latency = madmin.LatencyStat{
				Curr: epHealth.latency.curr,
				Avg:  epHealth.latency.avg,
				Max:  epHealth.latency.peak,
			}
		}
		m[dID] = metric
	}
	return m
}

func (srs *SRStatus) updateXferRate(sz int64, duration time.Duration) {
	if sz > minLargeObjSize {
		srs.XferRateLrg.addSize(sz, duration)

* Webhook client credentials configured with `--admission-control-config-file` must include non-default ports in the configured hostnames. For example, a webhook configured to speak to port 8443 on service `mysvc` in namespace `myns` would specify client credentials in a stanza with `name: mysvc.myns.svc:8443`. See https://kubernetes.io/docs/reference/access-authn-authz/extensible-admission-controllers/#authenticate-apiservers...

			if len(qs.XferStats) > 0 {
				tots := qs.XferStats[Total]
				currTransferRate.Value = tots.Curr
				avgTransferRate.Value = tots.Avg
				maxTransferRate.Value = tots.Peak
			}
			ml = []MetricV2{
				activeWorkersCount,
				avgActiveWorkersCount,
				maxActiveWorkersCount,
				currInQueueCount,
				currInQueueBytes,
				avgQueueCount,
				avgQueueBytes,